Initialization (iOS)

The symbols below are verified against the current iOS source. The agent-driven path — generateConnectionModule(platform: "ios") — emits this wiring for you; package install: Install.

Create the instance

The entry point is the Extentos enum. Call Extentos.create(config:) with an ExtentosConfig, or Extentos.default() for defaults. Both return an ExtentosGlasses — the root object that owns every capability sub-client.

import GlassesCore

let glasses = Extentos.create(config: ExtentosConfig(
    appId: "com.example.myapp",
    transport: .auto,
    usedCapabilities: [.microphone, .speaker],
))

usedCapabilities is not decoration on iOS — it picks the transport (see the callout below). Declare your real footprint: [.microphone, .speaker] for a voice app, plus .camera / .display if you use them. Leave debug at its default unless you are driving the browser-simulator dev loop; debug: true opens a pending simulator socket and waits for the MCP bridge to bind it.

transport: .auto walks these rules in order, stopping at the first match:

Every debug above is the ExtentosConfig.debug field, not your Xcode build configuration. It defaults to false, so a normal Debug-configuration run of a voice app skips rungs 1, 2 and 4 and lands on 5a — the audio baseline — exactly like a release build. Set debug: true only when you are driving the browser-simulator dev loop; on a phone with no bridge running it parks on rung 4 and waits.

It never falls back to a simulator on its own.

ExtentosConfig(usedCapabilities: [.microphone, .speaker])

The simulator runs the same SDK code as hardware; see transport vs app simulation. Hold a single instance for the app's lifetime.

Extentos.create(config:) is the customer entry point. Wearables.configure(...) is an internal Meta DAT type — you never call it directly.

Forward the auth callback (.onOpenURL)

Pairing with Meta Ray-Ban hands control to Meta's app and returns through your app's custom URL scheme. Catch that callback in SwiftUI's .onOpenURL and forward it to glasses.handleUrl(_:), which returns true when the SDK consumed the URL:

import SwiftUI

@main
struct MyApp: App {
    let glasses = Extentos.default()

    var body: some Scene {
        WindowGroup {
            ContentView()
                .onOpenURL { url in
                    Task { _ = await glasses.handleUrl(url) }
                }
        }
    }
}

handleUrl(_:) is async and returns a Bool. The simulator transports return false unconditionally — only the real-Meta transport consumes the registration callback. The matching Info.plist CFBundleURLTypes entry must register the scheme, or iOS never delivers the URL.

Request speech authorization (optional)

On-device transcription (glasses.audio.transcriptions()) uses SFSpeechRecognizer, which needs NSSpeechRecognitionUsageDescription in the Info.plist and a one-time user grant. The SDK requests it on first use, but you can surface the prompt at a controlled moment — e.g. during onboarding:

let granted = await Extentos.requestSpeechRecognitionAuthorization()

It returns true when authorized.

The microphone is a separate grant, and it's yours. Speech-recognition authorization does not cover audio capture. Request both before starting the assistant — iOS will otherwise prompt mid-session, or capture silence:

// AVAudioApplication is iOS 17+. On an iOS 16 target use
// AVAudioSession.sharedInstance().requestRecordPermission { granted in … }
let mic = await AVAudioApplication.requestRecordPermission()
let speech = await Extentos.requestSpeechRecognitionAuthorization()
guard mic, speech else { return }   // surface your own explanation
try await glasses.assistant.start(provider: .managed()) { … }

Both need their Info.plist strings (NSMicrophoneUsageDescription, NSSpeechRecognitionUsageDescription) or the app is terminated on first use — see Info.plist. This is the iOS counterpart of the Android sequencing in the voice-assistant guide; iOS needs no foreground service, only the audio background mode.

The sub-client surface

ExtentosGlasses exposes typed capability sub-clients. Reach a primitive through its client — e.g. glasses.camera.capturePhoto(), glasses.audio.transcriptions(), glasses.audio.speak(...).

The root object also exposes usedCapabilities (the declared capability footprint from ExtentosConfig) and a connect() convenience — what the generated bootstrap calls, equivalent to connection.connect().

Assistant

The assistant client is the voice-AI runtime. It routes through the Extentos managed gateway on both platforms — no API key in code. Start a session with the sugar form (builds the config inline), or use the raw form createSession(config:) + session.start():

let session = try await glasses.assistant.start(provider: .managed()) {
    $0.instructions = "You are a helpful assistant on smart glasses."
}

An AssistantSession has a wake/sleep cycle: start() lands it Dormant, wake() opens the realtime connection, sleep() closes it but keeps the session (history, tools, hooks) ready for the next wake, stop() tears it down for good. See the iOS API reference for the full session surface and the agent code examples for canonical flows.

Next

• Info.plist setup — the keys this wiring depends on.
• Threading model — how to call these async clients safely.
• Lifecycle — tearing the instance down with shutdown().

Related