Configuration

You can use the SDK with the default configuration or customize it to your needs.

You can visit the Web Playground at playground.shen.ai to see all configuration options in context (you’ll need an Web API key to access the playground).

Initializing the SDK without providing a custom configuration will use the default one - a one-minute strict-precision measurement displaying all metrics with full user interface. You can customize the behaviour and appearance of the SDK by providing a custom configuration object at initialization or by changing the configuration properties at runtime.

Prefer a no-code approach to updating your SDK configuration? Check out our Remote Configuration feature.

Initialization Mode

This parameter determines which mode the SDK uses:

MEASUREMENT (default): standard measurement with no calibration data.
CALIBRATION: starts the calibration workflow, requiring external BP readings and performing multiple SDK scans.
CALIBRATED_MEASUREMENT: applies previously stored calibration data (if available) to adjust blood pressure metrics.

See Calibration for a full description of these modes and usage instructions.

Measurement settings

`OperatingMode`

You can control the SDK behaviour by setting the Operating Mode:

Positioning: the SDK will track the user’s face position and give feedback to the user to keep the face in a proper position for starting the measurement. This is the default mode after the SDK is initialized.
Measure: the SDK will start the measurement as soon as the face is in a proper position.
SystemOverloaded: the SDK cannot keep up with the computations, the measurement is stopped and few seconds of rest are required to start a new measurement. This is a read-only mode, you cannot set it yourself neither can you unset it when it is active.

Clicking on the START/STOP button in the embedded user interface will switch between Positioning and Measure modes. You can also switch between those modes programmatically or start the SDK in the Measure mode by providing a custom configuration object at initialization:

enum OperatingMode {
  positioning,
  measure,
  systemOverloaded
}
 
var mode = await ShenaiSdk.getOperatingMode();
 
ShenaiSdk.setOperatingMode(OperatingMode.measure);
ShenaiSdk.setOperatingMode(OperatingMode.positioning);

import {getOperatingMode, setOperatingMode, OperatingMode} from 'react-native-shenai-sdk';
 
const mode = await getOperatingMode();
 
setOperatingMode(OperatingMode.MEASURE);
setOperatingMode(OperatingMode.POSITIONING);

enum OperatingMode {
  case positioning
  case measure
  case systemOverloaded
}
 
let mode = ShenaiSdk.getOperatingMode()
 
ShenaiSdk.setOperatingMode(.measure)
ShenaiSdk.setOperatingMode(.positioning)

enum OperatingMode {
  POSITIONING,
  MEASURE,
  SYSTEM_OVERLOADED
}
 
OperatingMode mode = shenaiSDK.getOperatingMode();
 
shenaiSDK.setOperatingMode(ShenAIAndroidSDK.OperatingMode.MEASURE);
shenaiSDK.setOperatingMode(ShenAIAndroidSDK.OperatingMode.POSITIONING);

import { OperatingMode } from "shenai-sdk";
 
shenaiSDK.initialize(..., {
  operatingMode: OperatingMode.MEASURE,
  ...
});
 
const mode = shenaiSDK.getOperatingMode();
 
switch (mode) {
  case OperatingMode.POSITIONING:
    console.log("SDK is positioning");
    break;
  case OperatingMode.MEASURE:
    console.log("SDK is measuring");
    break;
  case OperatingMode.SYSTEM_OVERLOADED:
    console.log("SDK is paused due to system overload");
    break;
}
 
shenaiSDK.setOperatingMode(OperatingMode.POSITIONING);
shenaiSDK.setOperatingMode(OperatingMode.MEASURE);
// shenaiSDK.setOperatingMode(OperatingMode.SYSTEM_OVERLOADED); // not allowed

`PrecisionMode`

By default, the SDK will use the strict precision mode, which will only return results if the signal quality is high enough (the threshold is determined by tests on Shen.AI’s internal datasets with high-quality ECG-based Ground Truth). You may choose to use the relaxed precision mode, which will return results even if the signal quality is low.

Strict: the SDK will only return results if the signal quality is high enough. This is the default mode after the SDK is initialized.
Relaxed: the SDK will return results on a best-effort basis. The results obtained in this mode should not be relied upon and represent the best guess given the current conditions.

enum PrecisionMode {
  strict,
  relaxed,
}
 
var mode = await ShenaiSdk.getPrecisionMode();
 
ShenaiSdk.setPrecisionMode(PrecisionMode.strict);
ShenaiSdk.setPrecisionMode(PrecisionMode.relaxed);

import {getPrecisionMode, setPrecisionMode, PrecisionMode} from 'react-native-shenai-sdk';
 
const mode = await getPrecisionMode();
 
setPrecisionMode(PrecisionMode.STRICT);
setPrecisionMode(PrecisionMode.RELAXED);

enum PrecisionMode {
  case strict
  case relaxed
}
 
let mode = ShenaiSDK.getPrecisionMode()
 
ShenaiSDK.setPrecisionMode(.strict)
ShenaiSDK.setPrecisionMode(.relaxed)

enum PrecisionMode {
  STRICT,
  RELAXED
}
 
PrecisionMode mode = shenaiSDK.getPrecisionMode();
 
shenaiSDK.setPrecisionMode(ShenAIAndroidSDK.PrecisionMode.STRICT);
shenaiSDK.setPrecisionMode(ShenAIAndroidSDK.PrecisionMode.RELAXED);

import { PrecisionMode } from "shenai-sdk";
 
shenaiSDK.initialize(..., {
  precisionMode: PrecisionMode.STRICT,
  ...
});
 
const mode = shenaiSDK.getPrecisionMode();
 
switch (mode) {
  case PrecisionMode.STRICT:
    console.log("SDK precision mode: STRICT");
    break;
  case PrecisionMode.RELAXED:
    console.log("SDK precision mode: RELAXED");
    break;
}
 
shenaiSDK.setPrecisionMode(PrecisionMode.STRICT);
shenaiSDK.setPrecisionMode(PrecisionMode.RELAXED);

`MeasurementPreset`

The following measurement presets are available:

OneMinuteHrHrvBr: a one-minute measurement that returns Heart Rate, Heart Rate Variability and Breathing Rate. This is the default preset after the SDK is initialized.
OneMinuteBetaMetrics: a one-minute measurement that includes metrics that are currently in beta - Blood Pressure and Stress Index.
InfiniteHr: an infinite measurement that provides continuous Heart Rate without any end condition.
InfiniteMetrics: an infinite measurement that provides multiple continuous metrics without any end condition (currently available metrics are Heart Rate, Heart Rate Variability and Stress Index) .

In addition, the following unvalidated presets are available which allow for shorter measurement times:

FourtyFiveSecondsUnvalidated: a 45 seconds measurement that includes all metrics
ThirtySecondsUnvalidated: a 30 seconds measurement that includes all metrics

⚠️

Please be aware that results from shorter measurement times have not been validated and might result in less accurate or less reliable metrics. This is particularly relevant for Heart Rate Variability (HRV) and Stress Index computations. These metrics depend on the analysis of variations in inter-beat intervals, which requires capturing a sufficient number of heartbeats to provide a reliable picture of autonomic nervous system activity. Shorter measurements might not provide enough data, leading to potential misinterpretations. Additionally, the precision of Blood Pressure computations may also be affected by shorter measurement times. For meaningful and reliable computations of HRV, Stress Index, and Blood Pressure, longer measurement times are strongly recommended.

enum MeasurementPreset {
  oneMinuteHrHrvBr,
  oneMinuteBetaMetrics,
  infiniteHr,
  infiniteMetrics,
  fourtyFiveSecondsUnvalidated,
  thirtySecondsUnvalidated,
  custom,
}
 
var preset = await ShenaiSdk.getMeasurementPreset();
 
ShenaiSdk.setMeasurementPreset(MeasurementPreset.oneMinuteHrHrvBr);
ShenaiSdk.setMeasurementPreset(MeasurementPreset.oneMinuteBetaMetrics);
ShenaiSdk.setMeasurementPreset(MeasurementPreset.infiniteHr);
ShenaiSdk.setMeasurementPreset(MeasurementPreset.infiniteMetrics);
ShenaiSdk.setMeasurementPreset(MeasurementPreset.fourtyFiveSecondsUnvalidated);
ShenaiSdk.setMeasurementPreset(MeasurementPreset.thirtySecondsUnvalidated);

import {getMeasurementPreset, setMeasurementPreset, MeasurementPreset} from 'react-native-shenai-sdk';
 
const preset = await getMeasurementPreset();
 
setMeasurementPreset(MeasurementPreset.ONE_MINUTE_HR_HRV_BR);
setMeasurementPreset(MeasurementPreset.ONE_MINUTE_BETA_METRICS);
setMeasurementPreset(MeasurementPreset.INFINITE_HR);
setMeasurementPreset(MeasurementPreset.INFINITE_METRICS);
setMeasurementPreset(MeasurementPreset.FOURTY_FIVE_SECONDS_UNVALIDATED);
setMeasurementPreset(MeasurementPreset.THIRTY_SECONDS_UNVALIDATED);

enum MeasurementPreset {
  case oneMinuteHrHrvBr
  case oneMinuteBetaMetrics
  case infiniteHr
  case infiniteMetrics
  case fourtyFiveSecondsUnvalidated
  case thirtySecondsUnvalidated
  case custom
}
 
let preset = ShenaiSDK.getMeasurementPreset()
 
ShenaiSDK.setMeasurementPreset(.oneMinuteHrHrvBr)
ShenaiSDK.setMeasurementPreset(.oneMinuteBetaMetrics)
ShenaiSDK.setMeasurementPreset(.infiniteHr)
ShenaiSDK.setMeasurementPreset(.infiniteMetrics)
ShenaiSDK.setMeasurementPreset(.fourtyFiveSecondsUnvalidated)
ShenaiSDK.setMeasurementPreset(.thirtySecondsUnvalidated)

enum MeasurementPreset {
  ONE_MINUTE_HR_HRV_BR,
  ONE_MINUTE_BETA_METRICS,
  INFINITE_HR,
  INFINITE_METRICS,
  FOURTY_FIVE_SECONDS_UNVALIDATED,
  THIRTY_SECONDS_UNVALIDATED,
  CUSTOM
}
 
MeasurementPreset preset = shenaiSDK.getMeasurementPreset();
 
shenaiSDK.setMeasurementPreset(ShenAIAndroidSDK.MeasurementPreset.ONE_MINUTE_HR_HRV_BR);
shenaiSDK.setMeasurementPreset(ShenAIAndroidSDK.MeasurementPreset.ONE_MINUTE_BETA_METRICS);
shenaiSDK.setMeasurementPreset(ShenAIAndroidSDK.MeasurementPreset.INFINITE_HR);
shenaiSDK.setMeasurementPreset(ShenAIAndroidSDK.MeasurementPreset.INFINITE_METRICS);
shenaiSDK.setMeasurementPreset(ShenAIAndroidSDK.MeasurementPreset.FOURTY_FIVE_SECONDS_UNVALIDATED);
shenaiSDK.setMeasurementPreset(ShenAIAndroidSDK.MeasurementPreset.THIRTY_SECONDS_UNVALIDATED);

import { MeasurementPreset } from "shenai-sdk";
 
shenaiSDK.initialize(..., {
    measurementPreset: MeasurementPreset.ONE_MINUTE_HR_HRV_BR,
  },
  ...
);
 
const preset = shenaiSDK.getMeasurementPreset();
 
switch (preset) {
  case MeasurementPreset.ONE_MINUTE_HR_HRV_BR:
    console.log("SDK measurement preset: ONE_MINUTE_HR_HRV_BR");
    break;
  case MeasurementPreset.ONE_MINUTE_BETA_METRICS:
    console.log("SDK measurement preset: ONE_MINUTE_BETA_METRICS");
    break;
  case MeasurementPreset.INFINITE_HR:
    console.log("SDK measurement preset: INFINITE_HR");
    break;
  case MeasurementPreset.INFINITE_METRICS:
    console.log("SDK measurement preset: INFINITE_METRICS");
    break;
  case MeasurementPreset.FOURTY_FIVE_SECONDS_UNVALIDATED:
    console.log("SDK measurement preset: FOURTY_FIVE_SECONDS_UNVALIDATED");
    break;
  case MeasurementPreset.THIRTY_SECONDS_UNVALIDATED:
    console.log("SDK measurement preset: THIRTY_SECONDS_UNVALIDATED");
    break;
}
 
// To change presets:
shenaiSDK.setMeasurementPreset(MeasurementPreset.ONE_MINUTE_HR_HRV_BR);
shenaiSDK.setMeasurementPreset(MeasurementPreset.ONE_MINUTE_BETA_METRICS);
shenaiSDK.setMeasurementPreset(MeasurementPreset.INFINITE_HR);
shenaiSDK.setMeasurementPreset(MeasurementPreset.INFINITE_METRICS);
shenaiSDK.setMeasurementPreset(MeasurementPreset.FOURTY_FIVE_SECONDS_UNVALIDATED);
shenaiSDK.setMeasurementPreset(MeasurementPreset.THIRTY_SECONDS_UNVALIDATED);

Custom measurement configuration

If the default presets don’t fit your needs, you can provide the SDK with a custom measurement configuration. The custom configuration makes it possible to determine which metrics should be displayed to the user in the embedded UI. It also allows you to set the measurement duration and period of the momentary metrics.

instantMetrics - a list of metrics that will be displayed to the user in the UI visible during the measurement
summaryMetrics - a list of metrics that will be displayed to the user in the summary UI visible after the measurement
healthIndices - a list of health indices that will be displayed to the user on the Health Indices screen
durationSeconds - the duration of the measurement in seconds. The default value is 60 seconds. Accepted values are between 15 and 120 seconds.
infiniteMeasurement - if set to true, the measurement will continue indefinitely until the user stops it. Progress bar is not shown and displayed realtime metrics are limited to HR, HRV and Stress Index. The default value is false.
realtimeHrPeriodSeconds - determines the period in time from which momentary heart rate is calculated. The default value is 10 seconds. Accepted values are between 4 and 60 seconds.
realtimeHrvPeriodSeconds (only applies in infinite mode) - determines the period in time from which momentary heart rate variability is calculated. The default value is 30 seconds. Accepted values are between 10 and 60 seconds.
realtimeCardiacStressPeriodSeconds (only applies in infinite mode) - determines the period in time from which momentary Stress Index is calculated. The default value is 30 seconds. Accepted values are between 10 and 60 seconds.

class CustomMeasurementConfig {
  double? durationSeconds;
  bool? infiniteMeasurement;
  List<Metric>? instantMetrics;
  List<Metric>? summaryMetrics;
  List<HealthIndex>? healthIndices;
  double? realtimeHrPeriodSeconds;
  double? realtimeHrvPeriodSeconds;
  double? realtimeCardiacStressPeriodSeconds;
}
 
ShenaiSdk.setCustomMeasurementConfig(config);

import {setCustomMeasurementConfig, CustomMeasurementConfig} from 'react-native-shenai-sdk';
 
interface CustomMeasurementConfig {
  durationSeconds?: number;
  infiniteMeasurement?: boolean;
 
  instantMetrics?: Metric[];
  summaryMetrics?: Metric[];
  healthIndices?: HealthIndex[];
 
  realtimeHrPeriodSeconds?: number;
  realtimeHrvPeriodSeconds?: number;
  realtimeCardiacStressPeriodSeconds?: number;
}
 
setCustomMeasurementConfig(config);

class MeasurementResults {
  var durationSeconds: NSNumber?
  var infiniteMeasurement: Bool
  var instantMetrics: [Metric]?
  var summaryMetrics: [Metric]?
  var healthIndices: [HealthIndex]?
  var realtimeHrPeriodSeconds: NSNumber?
  var realtimeHrvPeriodSeconds: NSNumber?
  var realtimeCardiacStressPeriodSeconds: NSNumber?
}
 
ShenaiSDK.setCustomMeasurementConfig(config);

class CustomMeasurementConfig {
  public Optional<Float> durationSeconds;
  public Optional<Boolean> infiniteMeasurement;
 
  public Optional<List<Metric>> instantMetrics;
  public Optional<List<Metric>> summaryMetrics;
  public Optional<List<HealthIndex>> healthIndices;
 
  public Optional<Float> realtimeHrPeriodSeconds;
  public Optional<Float> realtimeHrvPeriodSeconds;
  public Optional<Float> realtimeCardiacStressPeriodSeconds;
}
 
shenaiSDK.setCustomMeasurementConfig(config);

import { Metric } from "shenai-sdk";
 
// This is how the interface is defined
interface CustomMeasurementConfig {
  durationSeconds?: number;
  infiniteMeasurement?: boolean;
 
  instantMetrics?: Metric[];
  summaryMetrics?: Metric[];
  healthIndices?: HealthIndex;
 
  realtimeHrPeriodSeconds?: number;
  realtimeHrvPeriodSeconds?: number;
  realtimeCardiacStressPeriodSeconds?: number;
}
 
// This is how you set a custom configuration
shenaiSDK.setCustomMeasurementConfig({
  durationSeconds: 45,
  instantMetrics: [Metric.HEART_RATE],
  summaryMetrics: [Metric.SYSTOLIC_BP, Metric.DIASTOLIC_BP]
});
 
// Posible metrics:
Metric.HEART_RATE;
Metric.HRV_SDNN;
Metric.BREATHING_RATE;
Metric.SYSTOLIC_BP;
Metric.DIASTOLIC_BP;
Metric.CARDIAC_STRESS;
Metric.PNS_ACTIVITY;
Metric.CARDIAC_WORKLOAD;
Metric.AGE;
Metric.BMI;

💡

Note that if Blood Pressure is not included in either instant or summary metrics, the SDK will not compute it and it will not be available via the getMeasurementResults() method.

`CameraMode`

The SDK can be in one of the four camera modes:

Off: the camera is turned off.
FacingUser: the user-facing camera of the device is used (such as the front camera on a phone). This is the default mode after the SDK is initialized.
FacingEnvironment: the outside-facing camera of the device is used (such as the back camera on a phone).
DeviceId: one of the available cameras is used, selected by device ID (available only on Desktop Web).

enum CameraMode {
  off,
  facingUser,
  facingEnvironment,
}
 
var mode = await ShenaiSdk.getCameraMode();
 
ShenaiSdk.setCameraMode(CameraMode.off);
ShenaiSdk.setCameraMode(CameraMode.facingUser);
ShenaiSdk.setCameraMode(CameraMode.facingEnvironment);

import {getCameraMode, setCameraMode, CameraMode} from 'react-native-shenai-sdk';
 
const mode = await getCameraMode();
 
setCameraMode(CameraMode.OFF);
setCameraMode(CameraMode.FACING_USER);
setCameraMode(CameraMode.FACING_ENVIRONMENT);

enum CameraMode {
  case off
  case facingUser
  case facingEnvironment
}
 
let mode = ShenaiSDK.getCameraMode()
 
ShenaiSDK.setCameraMode(.off)
ShenaiSDK.setCameraMode(.facingUser)
ShenaiSDK.setCameraMode(.facingEnvironment)

 
enum CameraMode {
  OFF,
  FACING_USER,
  FACING_ENVIRONMENT
}
 
CameraMode mode = shenaiSDK.getCameraMode();
 
shenaiSDK.setCameraMode(ShenAIAndroidSDK.CameraMode.OFF);
shenaiSDK.setCameraMode(ShenAIAndroidSDK.CameraMode.FACING_USER);
shenaiSDK.setCameraMode(ShenAIAndroidSDK.CameraMode.FACING_ENVIRONMENT);

import { CameraMode } from "shenai-sdk";
 
shenaiSDK.initialize(..., {
cameraMode: CameraMode.FACING_USER,
...
});
 
const mode = shenaiSDK.getCameraMode();
 
shenaiSDK.setCameraMode(CameraMode.OFF);
shenaiSDK.setCameraMode(CameraMode.FACING_USER);
shenaiSDK.setCameraMode(CameraMode.FACING_ENVIRONMENT);
shenaiSDK.setCameraMode(CameraMode.DEVICE_ID); // Desktop only
 
// you can select one from the available cameras (Desktop only)
navigator.mediaDevices.enumerateDevices().then(devices => {
  const cameras = devices.filter(d => d.kind == "videoinput");
  const cameraIdx = 0;
  if (cameraIdx < cameras.length) {
    const deviceId = cameras[cameraIdx].deviceId;
    const facingUser = false;
    // selects the camera by device ID (also sets DEVICE_ID mode)
    shenaiSDK.selectCameraByDeviceId(deviceId, facingUser /* true by default if not specified */);
  }
});

Note that on Desktop, the camera swap button loops through all the available cameras only if DEVICE_ID mode is set. Otherwise it just switches between FACING_USER and FACING_ENVIRONMENT modes.

Preview settings

You can customize the SDK’s embedded UI to suit your use case with the settings below.

The easiest way to understand the settings and color themes is in the Web Playground at playground.shen.ai (you’ll need an Web API key to access the playground).

User Onboarding

User Onboarding offers a guided experience for users to understand and execute measurements effectively. Through a series of screens with clear graphics and instructions, users learn how the measurement process works and how to perform it accurately. This feature ensures a smooth introduction to the technology, enabling users to grasp its functionalities swiftly for precise measurements.

At SDK initialization, you can choose the preferred onboarding mode (onboardingMode in InitializationSettings). There are three options:

Hidden: user onboarding is never shown
ShowOnce: user onboarding is shown once for a user (this is the default option)
ShowAlways: user onboarding is shown on every initialization

enum OnboardingMode {
  hidden,
  showOnce,
  showAlways,
}

enum OnboardingMode {
  HIDDEN = 0,
  SHOW_ONCE,
  SHOW_ALWAYS,
}

enum OnboardingMode {
  case hidden
  case showOnce
  case showAlways
}

enum OnboardingMode {
  HIDDEN,
  SHOW_ONCE,
  SHOW_ALWAYS
}

import { OnboardingMode } from "shenai-sdk";
 
// Possible values:
OnboardingMode.HIDDEN;
OnboardingMode.SHOW_ONCE;
OnboardingMode.SHOW_ALWAYS;

Translation

The SDK’s embedded UI can be displayed in a different language instead of the default English. You can use the setLanguage method to change the language of the SDK’s embedded UI. The language is set by providing a two-letter language code (ISO 639-1).

You can see the currently available languages in the Web Playground.

Note that some languages are machine-translated to test the feature. If you would like to add a new language or improve the existing translation, please contact us.

ShenaiSdk.setLanguage("es");

import {
  setLanguage
} from 'react-native-shenai-sdk';
 
setLanguage("es");

ShenaiSDK.setLanguage("es");

shenaiSDK.setLanguage("es");

shenaiSDK.setLanguage("es");

UI elements

You can customize the user feedback interface by changing the following settings:

ShowUserInterface controls whether the user feedback interface is shown. If set to false, the SDK will not display any interactive elements such as the START/STOP button or the results section.
ShowFacePositioningOverlay controls whether the face positioning overlay is shown. If set to false, the SDK will not display the overlay that guides the user to position their face correctly.
ShowVisualWarnings controls whether visual warnings are shown. If set to false, the SDK will not display any visual warnings such as the red bulb that indicates that the signal quality is low.
EnableCameraSwap controls whether the user can switch between the front and back camera. If set to false, the user will not be able to switch between the front and back camera.
ShowFaceMask controls whether the face mask visualization is shown. If set to false, the SDK will not display the 3d face mask visualization.
ShowBloodFlow controls whether the blood flow visualization is shown. If set to false, the SDK will not display the blood flow visualization as an overlay on the user’s face.
EnableStartAfterSuccess controls whether the START button is available after a successful measurement. If set to false, the START button will not be available after a successful measurement until the SDK is reinitialized.

ShenaiSdk.setShowUserInterface(true);
ShenaiSdk.getShowUserInterface();
 
ShenaiSdk.setShowFacePositioningOverlay(true);
ShenaiSdk.getShowFacePositioningOverlay();
 
ShenaiSdk.setShowVisualWarnings(true);
ShenaiSdk.getShowVisualWarnings();
 
ShenaiSdk.setEnableCameraSwap(true);
ShenaiSdk.getEnableCameraSwap();
 
ShenaiSdk.setShowFaceMask(true);
ShenaiSdk.getShowFaceMask();
 
ShenaiSdk.setShowBloodFlow(true);
ShenaiSdk.getShowBloodFlow();
 
ShenaiSdk.setEnableStartAfterSuccess(true);
ShenaiSdk.getEnableStartAfterSuccess();

import {
  setShowUserInterface,
  getShowUserInterface,
  setShowFacePositioningOverlay,
  getShowFacePositioningOverlay,
  setShowVisualWarnings,
  getShowVisualWarnings,
  setEnableCameraSwap,
  getEnableCameraSwap,
  setShowFaceMask,
  getShowFaceMask,
  setShowBloodFlow,
  getShowBloodFlow,
  setEnableStartAfterSuccess,
  getEnableStartAfterSuccess
} from 'react-native-shenai-sdk';
 
setShowUserInterface(true);
const showUserInterface = await getShowUserInterface();
 
setShowFacePositioningOverlay(true);
const showFacePositioningOverlay = await getShowFacePositioningOverlay();
 
setShowVisualWarnings(true);
const showVisualWarnings = await getShowVisualWarnings();
 
setEnableCameraSwap(true);
const enableCameraSwap = await getEnableCameraSwap();
 
setShowFaceMask(true);
const showFaceMask = await getShowFaceMask();
 
setShowBloodFlow(true);
const showBloodFlow = await getShowBloodFlow();
 
setEnableStartAfterSuccess(true);
const enableStartAfterSuccess = await getEnableStartAfterSuccess();

ShenaiSDK.setShowUserInterface(true)
let showUserInterface = ShenaiSDK.getShowUserInterface()
 
ShenaiSDK.setShowFacePositioningOverlay(true)
let showFacePositioningOverlay = ShenaiSDK.getShowFacePositioningOverlay()
 
ShenaiSDK.setShowVisualWarnings(true)
let showVisualWarnings = ShenaiSDK.getShowVisualWarnings()
 
ShenaiSDK.setEnableCameraSwap(true)
let enableCameraSwap = ShenaiSDK.getEnableCameraSwap()
 
ShenaiSDK.setShowFaceMask(true)
let showFaceMask = ShenaiSDK.getShowFaceMask()
 
ShenaiSDK.setShowBloodFlow(true)
let showBloodFlow = ShenaiSDK.getShowBloodFlow()
 
ShenaiSDK.setEnableStartAfterSuccess(true)
let enableStartAfterSuccess = ShenaiSDK.getEnableStartAfterSuccess()

shenaiSDK.setShowUserInterface(true);
boolean showUserInterface = shenaiSDK.getShowUserInterface();
 
shenaiSDK.setShowFacePositioningOverlay(true);
boolean showFacePositioningOverlay = shenaiSDK.getShowFacePositioningOverlay();
 
shenaiSDK.setShowVisualWarnings(true);
boolean showVisualWarnings = shenaiSDK.getShowVisualWarnings();
 
shenaiSDK.setEnableCameraSwap(true);
boolean enableCameraSwap = shenaiSDK.getEnableCameraSwap();
 
shenaiSDK.setShowFaceMask(true);
boolean showFaceMask = shenaiSDK.getShowFaceMask();
 
shenaiSDK.setShowBloodFlow(true);
boolean showBloodFlow = shenaiSDK.getShowBloodFlow();

shenaiSDK.setShowUserInterface(true);
const showUserInterface = shenaiSDK.getShowUserInterface();
 
shenaiSDK.setShowFacePositioningOverlay(true);
const showFacePositioningOverlay = shenaiSDK.getShowFacePositioningOverlay();
 
shenaiSDK.setShowVisualWarnings(true);
const showVisualWarnings = shenaiSDK.getShowVisualWarnings();
 
shenaiSDK.setEnableCameraSwap(true);
const enableCameraSwap = shenaiSDK.getEnableCameraSwap();
 
shenaiSDK.setShowFaceMask(true);
const showFaceMask = shenaiSDK.getShowFaceMask();
 
shenaiSDK.setShowBloodFlow(true);
const showBloodFlow = shenaiSDK.getShowBloodFlow();

Color theme

The color theme of the SDK’s embedded UI can be changed by specifying alternative colors:

themeColor - color of the START/STOP button text and the progress bar
textColor - color of the text in the results section
backgroundColor - color of the background of the results section and around the UI
tileColor - color of the tiles in the results section, the face positioning overlay, START/STOP button background, ‘swap camera’ button and ‘info’ button

class CustomColorTheme {
  String? themeColor;
  String? textColor;
  String? backgroundColor;
  String? tileColor;
}
 
ShenaiSdk.setCustomColorTheme(theme);

import {
  CustomColorTheme,
  setCustomColorTheme
} from 'react-native-shenai-sdk';
 
interface CustomColorTheme {
  themeColor: string;
  textColor: string;
  backgroundColor: string;
  tileColor: string;
}
 
setCustomColorTheme(theme);

class CustomColorTheme {
  var themeColor: String?
  var textColor: String?
  var backgroundColor: String?
  var tileColor: String?
}
 
ShenaiSDK.setCustomColorTheme(theme);

class CustomColorTheme {
  public String themeColor;
  public String textColor;
  public String backgroundColor;
  public String tileColor;
}
 
shenaiSDK.setCustomColorTheme(theme);

interface CustomColorTheme {
  themeColor: string;
  textColor: string;
  backgroundColor: string;
  tileColor: string;
}
 
shenaiSDK.setCustomColorTheme(theme);

Developer settings

The following settings are intended to be used by developers and shouldn’t be exposed to the end user.

Measurement recording

The SDK can record the measurement video and send it to Shen.AI for analysis. This is useful for debugging failure cases and registering edge cases. The recording is not saved on the device and is only available to Shen.AI.

Whenever recording mode is active, the SDK will display a red dot in the top right corner of the preview. For debugging, it’s also possible to activate recording mode by tapping three times on the Heart Rate tile.

One minute of recorded video is approximately 200 MB in size (lossless compression is used).

Shenaisdk.setRecordingEnabled(true);
Shenaisdk.getRecordingEnabled();

import {setRecordingEnabled, getRecordingEnabled} from 'react-native-shenai-sdk';
 
setRecordingEnabled(true);
const isEnabled = await getRecordingEnabled();

ShenaiSDK.setRecordingEnabled(true)
let isEnabled = ShenaiSDK.getRecordingEnabled()

shenaiSDK.setRecordingEnabled(true);
boolean isEnabled = shenaiSDK.getRecordingEnabled();

shenaiSDK.setRecordingEnabled(true);
shenaiSDK.getRecordingEnabled();

Initialization Flutter