Quick Start ​

This quick start guide describes the basic flow for measuring vital signs using Binah.ai SDK.

The SDK supports three measurements modes:

• Face Measurement
• Finger Measurement
• Polar Measurement

A sample flow for face measurement follows. A similar flow can be applied for finger measurements. See Measurement Modes for more information about measurement modes.

Creating a Measurement Session ​

A session is an interface for performing vital sign measurements.

• When creating a session, it is essential to define the measurement mode. The SDK supports three measurement modes:
  • Face Measurements (Front Camera): This mode utilizes the front camera for capturing face-related measurements.
  • Finger Measurements (Rear Camera): In this mode, the rear camera is used to take measurements from the user's finger.
  • Polar Measurements (External PPG Sensor): This mode enables measurements using the Polar Verity Sense sensor.
• Only a single session can be created at any given time. Terminate the previous session before creating a new session.
• When switching to a different measurement mode (for example, from face to finger, or from finger to face), the current session must be terminated, and a new session must be created.
• A session is intended for a single user. When measuring the vital signs of another user, a new session must be created. See Demographic Info.

The following code can be used to create a session with the relevant parameters:

try {
    val licenseDetails = LicenseDetails("<ENTER_YOUR_LICENSE_KEY>")
    val session = FaceSessionBuilder(applicationContext)
                    .withImageListener(this)
                    .withVitalSignsListener(this)
                    .withSessionInfoListener(this)
                    .build(licenseDetails)
} catch (e: HealthMonitorException) {
    Log.i("ERROR", "Received Error. Domain: ${e.domain} Code: ${e.errorCode}")
}

try {
    LicenseDetails licenseDetails = new LicenseDetails("<ENTER_YOUR_LICENSE_KEY>");
    Session session = new FaceSessionBuilder(getApplicationContext())
                    .withImageListener(this)
                    .withVitalSignsListener(this)
                    .withSessionInfoListener(this)
                    .build(licenseDetails);
} catch (HealthMonitorException e) {
    Log.i("ERROR", "Received Error. Domain: "+ e.getDomain() +" Code: "+ e.getErrorCode());
}

Waiting for the Session to Transition into READY State ​

The application can receive session state updates by implementing onSessionStateChange as part of SessionInfoListener.

override fun onSessionStateChange(sessionState: SessionState) {
    runOnUiThread {
        if (sessionState == SessionState.READY) {
            Log.i("SESSION_STATE", "Session is ready to start measuring");
        }
    }
}

@Override
public void onSessionStateChange(@NonNull SessionState sessionState) {
    runOnUiThread(() -> {
        if (state == SessionState.READY) {
            Log.i("SESSION_STATE", "Session is ready to start measuring");
        }
    });
}

Starting a Measurement ​

A measurement can be started by calling the start method

try {
    val measurementDuration = 60
    session.start(measurementDuration)
} catch (e: HealthMonitorException) {
    Log.i("ERROR", "Received Error. Domain: ${e.domain} Code: ${e.errorCode}")
}

try {
    long measurementDuration = 60;
    session.start(measurementDuration);
} catch (HealthMonitorException e) {
    Log.i("ERROR", "Received Error. Domain: "+ e.getDomain() +" Code: "+ e.getErrorCode());
}

Receiving Results During a Measurement ​

The application can receive instantaneous vital signs values by implementing onVitalSign as part of VitalSignsListener.

override fun onVitalSign(vitalSign: VitalSign) {
    // Handle vital sign result
}

@Override
 void onVitalSign(VitalSign vitalSign) {
    // Handle vital sign result
}

During the measurement, the instantaneous vital sign values are available only for specific vital signs, while the results of all vital signs are received once the measurement has been completed.

Stopping a Measurement ​

The measurement is stopped either after the measurement duration (provided in the start function) has ended, or when the stop method is called.

try {
    session.stop()
} catch (e: HealthMonitorException) {
    Log.i("ERROR", "Received Error. Domain: ${e.domain} Code: ${e.errorCode}")
}

try {
    session.stop();
} catch (HealthMonitorException e) {
    Log.i("ERROR", "Received Error. Domain: "+ e.getDomain() +" Code: "+ e.getErrorCode());
}

Receiving Final Results ​

The application can receive final vital sign results and vital sign confidence levels by implementing onFinalResults as part of VitalSignsListener.

override fun onFinalResults(results: VitalSignsResults) {
    // Handle the final results of the measurements
}

@Override
void onFinalResults(VitalSignsResults results) {
    // Handle the final results of the measurements
}

The final results are computed when the session is in STOPPING state. For more information about receiving and handling the final results, see Vital Signs.

Terminating a Session ​

It is recommended to terminate the session whenever the measuring screen is not visible.

session.terminate()

session.terminate();