API Reference

• Scan for a supported glasses model.
• Connect to a discovered Device or an app-restored default device.
• Read typed lifecycle state through the public surface for your platform.
• Subscribe to typed hardware events.
• Send camera, stream, audio, Wi-Fi, hotspot, LED, and settings commands for Mentra Live.

​

Packages And Imports

​

Lifecycle

import {useBluetoothEvent, useMentraBluetooth} from '@mentra/bluetooth-sdk/react';

function DeviceScreen() {
  const mentra = useMentraBluetooth();
  useBluetoothEvent('button_press', (event) => {
    console.log(event.buttonId, event.pressType);
  });

  console.log(mentra.glasses.connection.state);
}

val sdk = MentraBluetoothSdk.create(
    context = applicationContext,
    config = MentraBluetoothSdkConfig(),
    listener = listener,
)

sdk.close()

let sdk = MentraBluetoothSDK(configuration: .default)
sdk.delegate = delegate

sdk.invalidate()

​

Mentra SDK Usage Analytics

{
  "expo": {
    "plugins": [
      [
        "@mentra/bluetooth-sdk",
        {
          "analytics": false
        }
      ]
    ]
  }
}

val sdk = MentraBluetoothSdk.create(
    context = applicationContext,
    config = MentraBluetoothSdkConfig(
        analytics = BluetoothSdkAnalyticsConfig.disabled()
    ),
    listener = listener,
)

<meta-data
    android:name="com.mentra.bluetoothsdk.analytics.disabled"
    android:value="true" />

let sdk = MentraBluetoothSDK(
    configuration: MentraBluetoothSDKConfiguration(
        analytics: .disabled
    )
)

​

Connection

const devices = await BluetoothSdk.scan(DeviceModels.MentraLive, {
  timeoutMs: 10_000,
  onResults: (nextDevices) => renderDevicePicker(nextDevices),
});

const device = await chooseDevice(devices);
await BluetoothSdk.connect(device, {saveAsDefault: false});

await BluetoothSdk.setDefaultDevice(device);

async function reconnectSavedDevice() {
  const defaultDevice = await BluetoothSdk.getDefaultDevice();
  if (defaultDevice) {
    await BluetoothSdk.connectDefault();
  }
}

async function clearSavedDevice() {
  await BluetoothSdk.clearDefaultDevice();
}

async function stopConnection() {
  await BluetoothSdk.cancelConnectionAttempt();
  await BluetoothSdk.disconnect();
  await BluetoothSdk.forget();
}

val devices = mutableListOf<Device>()
val scanSession = sdk.scan(DeviceModel.MENTRA_LIVE, timeoutMs = 10_000) { nextDevices ->
    devices.clear()
    devices.addAll(nextDevices)
    renderDevicePicker(nextDevices, onSelect = { device ->
        sdk.connect(device)
        sdk.setDefaultDevice(device)
    })
}

fun reconnectSavedDevice() {
    val defaultDevice = sdk.getDefaultDevice()
    if (defaultDevice != null) {
        sdk.connectDefault()
    }
}

fun clearSavedDevice() {
    sdk.clearDefaultDevice()
}

fun stopConnection() {
    sdk.cancelConnectionAttempt()
    sdk.disconnect()
    sdk.forget()
}

var devices: [Device] = []
let scanSession = try sdk.scan(model: .mentraLive, timeout: 10) { nextDevices in
    devices = nextDevices
    renderDevicePicker(nextDevices) { device in
        do {
            try sdk.connect(to: device)
            sdk.setDefaultDevice(device)
        } catch {
            handleConnectionError(error)
        }
    }
}

func reconnectSavedDevice() throws {
    if sdk.getDefaultDevice() != nil {
        try sdk.connectDefault()
    }
}

func clearSavedDevice() {
    sdk.clearDefaultDevice()
}

func stopConnection() {
    sdk.cancelConnectionAttempt()
    sdk.disconnect()
    sdk.forget()
}

​

Device Identity

​

Status

import {useMentraBluetooth} from '@mentra/bluetooth-sdk/react';

const mentra = useMentraBluetooth();

type GlassesConnectionStatus =
  | {state: 'disconnected'}
  | {state: 'scanning'}
  | {state: 'connecting'}
  | {state: 'bonding'}
  | {state: 'connected'; fullyBooted: boolean};

val state = sdk.getState()
val glasses = sdk.getGlasses()
val sdkState = sdk.getSdkState()
val scan = sdk.getScanState()

let state = sdk.state
let glasses = sdk.glasses
let sdkState = sdk.sdkState
let scan = sdk.scanState

​

React Native Public Surface

• scan(model, options) reports progressive results through options.onResults, resolves with the final matching Device[], and times out after 15 seconds unless options.timeoutMs is set.
• connect and connectDefault default saveAsDefault and cancelExistingConnectionAttempt to true.
• setMicState(enabled) defaults to glasses microphone on, transcript events off, and LC3 events off. Microphone audio events are continuous while capture is enabled. Use setVoiceActivityDetectionEnabled(...) for glasses-side Voice Activity Detection; voice_activity_detection_status reports whether it is enabled, and speaking_status reports speaking/not-speaking when supported. Microphone audio events include the latest voiceActivityDetectionEnabled value.
• requestPhoto({authToken, ...}) omits the Authorization header when authToken is null or empty.
• requestPhoto(...) and warmUpCamera(...) generate unique request IDs when requestId is omitted or blank. Pass an explicit requestId only when your app needs to know it before the response, for example to poll a predictable upload-status URL.
• requestPhoto({exposureTimeNs, ...}) uses auto exposure when exposureTimeNs is omitted or null; pass a positive nanosecond value for one-shot manual exposure.
• requestPhoto({exposureTimeNs, iso, ...}) uses iso only when exposureTimeNs enables one-shot manual exposure. Omit iso / pass null for auto ISO selection.
• requestPhoto(...) capture fields apply to that one request. setPhotoCaptureDefaults(...) is deprecated; it still persists gallery-mode action-button photo defaults, but prefer per-request requestPhoto(...) options (e.g. mode: "text") instead.
• warmUpCamera({size, exposureTimeNs, durationMs}) opens/configures Mentra Live’s camera and holds it warm without capturing or uploading media. Use it while a foreground camera UI is active, refresh before durationMs expires, and match the next requestPhoto(...) size/exposure settings for reuse. The promise resolves on camera_status.state === "ready"; the later stopped event marks lease expiry/teardown for listeners and does not settle the already-resolved promise.
• Request/response commands now resolve from the glasses response rather than only updating local SDK state. React Native returns success-only values for commands whose raw events can also carry errors: requestPhoto(...) returns terminal PhotoSuccessResponseEvent after capture and delivery finish, startVideoRecording(...) returns VideoRecordingStartedStatusEvent, stopVideoRecording(...) returns VideoRecordingStoppedStatusEvent, and rgbLedControl(...) returns RgbLedControlSuccessResponseEvent. When stopVideoRecording(...) includes a webhook URL, the promise resolves after the video upload succeeds. The corresponding raw events still include error variants for listeners.
• setCameraFov({fov, roiPosition}) clamps fov to 62-118 degrees and accepts roiPosition as "center", "bottom", or "top". You can also call setCameraFov({preset: "narrow" | "standard" | "wide"}); presets map to 82, 102, and 118 degrees with center ROI. On Mentra Live this persists the setting, restarts the camera, and resolves with CameraFovResult only after the ASG client reports the setting was applied to camera hardware after the restart cooldown. The promise rejects if the glasses report an error, persist the setting without hardware application, or time out. Treat FOV as a framing/ROI control; output resolution and effective detail can vary by capture path, firmware, and camera mode.
• startStream optional video and audio configs are omitted unless supplied, so the connected glasses use their model defaults. Stream video input fields are width, height, bitrate, and fps; stream status reports the resolved effective frame rate as resolvedConfig.video.fps. The SDK sends stream keep-alives automatically and reports timeout/error state through stream_status.
• Photo capture, video recording, and streaming always enable the camera light as a privacy indicator.

​

Promise Results And Errors

​

Gallery Mode

​

Common Commands

​

OTA Updates

​

Events

import {useBluetoothEvent} from '@mentra/bluetooth-sdk/react';

export function HardwareEventLogger() {
  useBluetoothEvent('button_press', (event) => console.log(event));
  useBluetoothEvent('touch_event', (event) => console.log(event));
  useBluetoothEvent('photo_status', (event) => console.log(event.status, event.resolvedConfig));
  useBluetoothEvent('stream_status', (event) => console.log(event.resolvedConfig?.video?.fps));
  useBluetoothEvent('ota_status', (event) => console.log(event.overall_percent));
  useBluetoothEvent('speaking_status', (event) => console.log(event.speaking));
  useBluetoothEvent('mic_pcm', (event) => {
    console.log(event.sampleRate, event.bitsPerSample, event.channels, event.encoding);
    console.log(event.pcm);
  });

  return null;
}

class GlassesEvents : MentraBluetoothSdkCallback() {
    override fun onButtonPress(event: ButtonPressEvent) {
        Log.d("Mentra", "${event.buttonId} ${event.pressType}")
    }

    override fun onPhotoResponse(event: PhotoResponseEvent) {
        Log.d("Mentra", "Photo request ${event.requestId}: ${event.response.state}")
    }

    override fun onMicPcm(event: MicPcmEvent) {
        Log.d("Mentra", "${event.sampleRate} Hz ${event.bitsPerSample}-bit PCM")
    }

    override fun onOtaStatus(event: OtaStatusEvent) {
        Log.d("Mentra", "OTA ${event.status}: ${event.overallPercent}%")
    }
}

final class GlassesEvents: MentraBluetoothSDKDelegate {
    func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didReceive event: BluetoothEvent) {
        switch event {
        case let .buttonPress(button):
            print("\(button.buttonId) \(button.pressType)")
        case let .photoResponse(photo):
            print("Photo request \(photo.requestId): \(photo.response.state.rawValue)")
        case let .otaStatus(status):
            print("OTA \(status.status): \(status.overallPercent)%")
        default:
            break
        }
    }

    func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didReceiveMicPcm event: MicPcmEvent) {
        print("\(event.sampleRate) Hz \(event.bitsPerSample)-bit PCM")
    }
}

​

Photo Status Metadata

​

Version Fields