Android quickstart

import com.neurofit.vitals.VitalsSDK
import com.neurofit.vitals.VitalsException

class App : Application() {
  override fun onCreate() {
    super.onCreate()
    try {
      val status = VitalsSDK.activate(this, BuildConfig.NEUROFIT_VITALS_LICENSE_KEY)
      Log.i("Vitals", "Licensed to ${status.licensee}, updates until ${status.updatesUntil}")
      status.warnings.forEach { Log.w("Vitals", "License warning: $it") }
    } catch (e: VitalsException) {
      // LicenseInvalid, LicenseNotValidForApp, LicenseUpdatesExpired
      Log.e("Vitals", "Activation failed", e)
    }
  }
}

import com.neurofit.vitals.VitalsSDK;
import com.neurofit.vitals.VitalsException;
import com.neurofit.vitals.LicenseStatus;

public class App extends Application {
  @Override public void onCreate() {
    super.onCreate();
    try {
      LicenseStatus status = VitalsSDK.activate(this, BuildConfig.NEUROFIT_VITALS_LICENSE_KEY);
      Log.i("Vitals", "Licensed to " + status.getLicensee());
    } catch (VitalsException e) {
      Log.e("Vitals", "Activation failed", e);
    }
  }
}

import android.view.WindowManager
import androidx.activity.ComponentActivity
import androidx.camera.view.PreviewView
import androidx.lifecycle.lifecycleScope
import com.neurofit.vitals.*
import kotlinx.coroutines.launch

class ReadingActivity : ComponentActivity() {
  private var session: VitalsSession? = null

  private fun startReading() {
    window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
    val session = VitalsSDK.createSession(this, VitalsConfig())
    this.session = session

    lifecycleScope.launch {
      session.events.collect { event ->
        when (event) {
          is VitalsEvent.Guidance -> showGuidance(event.guidance, event.startProgress)
          is VitalsEvent.Started -> showMeasuring()
          is VitalsEvent.Preview -> showLive(event.preview)     // rmssdMs from ~20 s, breathingRate from ~30 s
          is VitalsEvent.Heartbeat -> pulseAnimation(event.ibiMs)
          is VitalsEvent.Cancelled -> showRestartNote(event.reason)   // the session re-arms by itself
          is VitalsEvent.RecoverableError -> Log.w("Vitals", "Recovering: ${event.error}")
          is VitalsEvent.MeasurementComplete -> showFinalizing()
          is VitalsEvent.Completed -> showResult(event.result)
          is VitalsEvent.Failed -> showFailure(event.error)
          else -> Unit   // State, ReconfiguringCamera (never emitted on Android)
        }
      }
    }

    // The measuring clock ticks on state only (no State event per tick).
    lifecycleScope.launch {
      session.state.collect { state ->
        if (state is VitalsSessionState.Measuring) showElapsed(state.elapsed)
      }
    }

    // previewView is optional; pass null for a reading without a camera preview.
    session.start(owner = this, previewView = findViewById<PreviewView>(R.id.previewView))
  }

  private fun showFailure(error: VitalsException) {
    when (error) {
      is VitalsException.Interrupted -> showRetry("The reading was interrupted: ${error.reason}")
      is VitalsException.NoHeartRate -> showRetry("No pulse found. Rest your fingertip flat on the camera.")
      is VitalsException.UnsupportedDevice -> showUnsupported(error.reason)
      else -> showRetry(error.message ?: "Unexpected error")
    }
  }

  override fun onDestroy() {
    super.onDestroy()
    session?.stop()   // idempotent; torch off, the SDK's own camera use cases unbound
  }
}

import androidx.activity.ComponentActivity;
import androidx.core.content.ContextCompat;
import com.neurofit.vitals.*;

public class ReadingActivity extends ComponentActivity {
  private VitalsSession session;

  private void startReading() {
    VitalsConfig config = new VitalsConfig.Builder()
        .readingDuration(60.0)
        .autoRestartAfterCancel(true)
        .build();
    session = VitalsSDK.createSession(this, config);

    // Callbacks run on the executor you pass; the result arrives as VitalsEvent.Completed,
    // a terminal error as VitalsEvent.Failed.
    session.setListener(event -> {
      if (event instanceof VitalsEvent.Guidance g) {
        showGuidance(g.getGuidance(), g.getStartProgress());
      } else if (event instanceof VitalsEvent.Preview p) {
        showLive(p.getPreview());
      } else if (event instanceof VitalsEvent.Completed c) {
        showResult(c.getResult());
      } else if (event instanceof VitalsEvent.Failed f) {
        showFailure(f.getError());
      }
    }, ContextCompat.getMainExecutor(this));

    session.start(this, findViewById(R.id.previewView));
  }

  @Override protected void onDestroy() {
    super.onDestroy();
    if (session != null) session.stop();
  }
}