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()

​

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);

const defaultDevice = await BluetoothSdk.getDefaultDevice();
await BluetoothSdk.connectDefault();
await BluetoothSdk.clearDefaultDevice();

await BluetoothSdk.cancelConnectionAttempt();
await BluetoothSdk.disconnect();
await BluetoothSdk.forget();

val devices = mutableListOf<Device>()
var selectedDevice: Device? = null
val scanSession = sdk.scan(DeviceModel.MENTRA_LIVE, timeoutMs = 10_000) { nextDevices ->
    devices.clear()
    devices.addAll(nextDevices)
    renderDevicePicker(nextDevices, onSelect = { selectedDevice = it })
}

val device = selectedDevice ?: return
sdk.connect(device)
sdk.setDefaultDevice(device)
val defaultDevice = sdk.getDefaultDevice()
sdk.connectDefault()
sdk.clearDefaultDevice()

sdk.cancelConnectionAttempt()
sdk.disconnect()
sdk.forget()

var devices: [Device] = []
var selectedDevice: Device? = nil
let scanSession = try sdk.scan(model: .mentraLive, timeout: 10) { nextDevices in
    devices = nextDevices
    renderDevicePicker(nextDevices) { device in
        selectedDevice = device
    }
}

guard let device = selectedDevice else { return }
try sdk.connect(to: device)
sdk.setDefaultDevice(device)
let defaultDevice = sdk.getDefaultDevice()
try sdk.connectDefault()
sdk.clearDefaultDevice()

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({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.
• 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. 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. 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