Meta Wearables Device Access Toolkit

https://wearables.developer.meta.com/docs
Admin
The Meta Wearables Device Access Toolkit enables iOS and Android developers to build mobile...
Tokens:192,861
Snippets:1,660
Trust Score:9.9
Update:1 week ago
Show doc for...
Tokens:
Raw
### Server setup (app process)

Source: https://wearables.developer.meta.com/docs/develop/dat/testing-mdk-ios

Starts the MockDevice test server when the app launches with a `--ui-testing` flag. The server should only be enabled in DEBUG builds. It reads the port file path from the environment variable `MWDAT_TEST_SERVER_PORT_FILE` and starts the server asynchronously.

```swift
import MWDATMockDevice

if ProcessInfo.processInfo.arguments.contains("--ui-testing") {
    MockDeviceKit.shared.enable(config: MockDeviceKitConfig(initiallyRegistered: false))

    let portFilePath = ProcessInfo.processInfo.environment["MWDAT_TEST_SERVER_PORT_FILE"]
    Task {
        try await MockDeviceKit.shared.startTestServer(portFilePath: portFilePath)
        // Server is now listening — tests drive mock device setup via HTTP
    }
}

```

--------------------------------

### Prompt for camera session and lifecycle setup

Source: https://wearables.developer.meta.com/docs/develop/dat/ai-assisted-cursor

Example prompt to use in Cursor Chat or inline editing to ask about setting up a Device Access Toolkit session with camera streaming and lifecycle events.

```text
Set up a Device Access Toolkit session with camera streaming and handle lifecycle events.

```

--------------------------------

### start()

Source: https://wearables.developer.meta.com/docs/reference/android/dat/latest/com_meta_wearable_dat_camera_stream

Starts the stream, activating the camera on glasses and beginning the streaming pipeline.

```APIDOC
## start()

### Description
Starts the stream, activating the camera on glasses and beginning the streaming pipeline. Call this after obtaining a Stream from Camera.stream. Adding the camera via DeviceSession.addCamera registers the capability, while `start()` activates the camera and begins video frame delivery.

### Method
start

### Signature
```kotlin
abstract fun start(): DatResult<Unit, StreamError>
```

### Returns
DatResult with Unit on success, or StreamError on failure
```

--------------------------------

### Start Claude Code in project directory

Source: https://wearables.developer.meta.com/docs/develop/dat/ai-assisted-claude-code

Starts Claude Code in your project directory. After setup, the Device Access Toolkit plugin is loaded and you can ask about SDK topics, implement app functionality, or write tests.

```bash
claude

```

--------------------------------

### Connect to the display and send a view

Source: https://wearables.developer.meta.com/docs/develop/dat/display-ios

Configure the SDK, create a session, start it, attach the display capability, start the display, and send a simple FlexBox/Text view once the display is started.

```swift
// Configure the SDK
try Wearables.configure()

// Create a session targeting display-capable glasses
let wearables = Wearables.shared
let session = try wearables.createSession()

// Start the session and wait for it to connect. Then observe session.stateStream() for .started
try session.start()

// Attach the display capability
let display = try session.addDisplay()

// Start the display and observe state. Then observe display.statePublisher for .started
display.start()

// Send content once the display reaches .started
let view = FlexBox(direction: .column, spacing: 12) {
    Text("Hello, glasses!", style: .heading)
}
try await display.send(view)

```

--------------------------------

### Prompt for grounded camera/lifecycle implementation

Source: https://wearables.developer.meta.com/docs/develop/dat/ai-assisted-cursor

Example prompt that combines installed Cursor guidance with the search_dat_docs MCP tool for current camera streaming and session lifecycle guidance. It instructs Cursor to inspect the project, make the smallest safe change, and run local checks.

```text
Use the installed Device Access Toolkit Cursor guidance for platform-specific implementation patterns. Then ask search_dat_docs for current camera streaming and session lifecycle guidance. Inspect my project first, make the smallest safe change, and run the relevant local checks.

```

--------------------------------

### start() signature

Source: https://wearables.developer.meta.com/docs/reference/android/dat/latest/com_meta_wearable_dat_core_session_devicesession

Starts the session, connecting to the device resolved during Wearables.createSession. Sync fire-and-forget; observe DeviceSession.state for STARTING → STARTED transitions and DeviceSession.errors for failures. Calling start on a session not in DeviceSessionState.IDLE is a no-op.

```kotlin
fun start()
```

--------------------------------

### DeviceSession.addSpeech example

Source: https://wearables.developer.meta.com/docs/reference/android/dat/latest/com_meta_wearable_dat_core_session_devicesession

Example of adding a speech capability to a session and collecting transcriptions. The speech capability must be added after the session is started; otherwise, errors like SESSION_IDLE or SESSION_ALREADY_STOPPED are returned.

```kotlin
session.addSpeech().fold(
    onSuccess = { speech ->
        speech.start().onFailure { error, _ -> showError(error.description) }
        scope.launch {
            speech.state.collect { state -> updateUi(state) }
        }
        scope.launch {
            speech.transcriptions.collect { result ->
                result?.let { if (it.isFinal) appendText(it.text) }
            }
        }
    },
    onFailure = { error, _ -> showError(error.description) },
)
```

--------------------------------

### Live docs lookup prompt with search_dat_docs

Source: https://wearables.developer.meta.com/docs/develop/dat/ai-assisted-muse

Example prompt for live docs lookup after approving the plugin; start a new session and confirm guidance and search_dat_docs are available. Public docs MCP server does not require authentication.

```text
Use the installed Device Access Toolkit plugin for platform-specific implementation patterns. Then ask search_dat_docs for current camera streaming and session lifecycle guidance. Inspect my project first, make the smallest safe change, and run the relevant local checks.
```

--------------------------------

### Start Chrome display preview with Mock Device Kit (iOS)

Source: https://wearables.developer.meta.com/docs/develop/dat/display-simulation

Starts a simulated display and preview server for the Meta Ray-Ban Display glasses. Uses MockDeviceKit to enable the device, pair the glasses, power them on, and start a test server on port 9000. Call this from a @MainActor context.

```swift
import MWDATMockDevice

private let displayPreviewPort: UInt16 = 9000

@MainActor
func startChromeDisplayPreview() async throws {
    let mockDeviceKit = MockDeviceKit.shared
    mockDeviceKit.enable()

    let mockGlasses = try mockDeviceKit.pairGlasses(model: .metaRayBanDisplay)
    mockGlasses.powerOn()
    mockGlasses.don()

    _ = try await mockDeviceKit.startTestServer(port: displayPreviewPort)
}

```

--------------------------------

### Install Cursor guidance for Android

Source: https://wearables.developer.meta.com/docs/develop/dat/ai-assisted-mcp

Installs the repo-native Cursor guidance for Android by running the install-skills.sh script with the cursor argument. Execute in a terminal.

```bash
curl -sL https://raw.githubusercontent.com/facebook/meta-wearables-dat-android/main/install-skills.sh | bash -s cursor

```

--------------------------------

### Install Cursor guidance for iOS

Source: https://wearables.developer.meta.com/docs/develop/dat/ai-assisted-mcp

Installs the repo-native Cursor guidance for iOS by running the install-skills.sh script with the cursor argument. Execute in a terminal.

```bash
curl -sL https://raw.githubusercontent.com/facebook/meta-wearables-dat-ios/main/install-skills.sh | bash -s cursor

```

--------------------------------

### Install Copilot skills locally

Source: https://wearables.developer.meta.com/docs/develop/dat/ai-assisted-github-copilot

Installs the GitHub Copilot skills for the Device Access Toolkit SDK when the repository was not cloned with the .github/copilot-instructions.md file included.

```bash
./install-skills.sh copilot

```

--------------------------------

### Prompt for building minimal iOS integration slice

Source: https://wearables.developer.meta.com/docs/develop/dat/build-integration-ios

A prompt to copy into an AI coding tool to build a minimal Wearables Device Access Toolkit integration slice. It instructs the tool to use the guide and MCP server, inspect the app, and add Info.plist setup, SDK imports, Wearables.configure(), app registration, and connection lifecycle wiring.

```text
Use https://wearables.developer.meta.com/docs/develop/dat/build-integration-ios/, then use the Wearables MCP endpoint https://mcp.developer.meta.com/wearables to call search_dat_docs for current iOS Wearables Device Access Toolkit setup, registration, permissions, session lifecycle, MockDeviceKit, and camera guidance. If the Device Access Toolkit iOS plugin is not installed, install it from https://github.com/facebook/meta-wearables-dat-ios (see https://wearables.developer.meta.com/docs/develop/dat/getting-started-toolkit/#set-up-ai-coding-tools) and use its skills. If search_dat_docs is unavailable, help me configure the Wearables MCP server from https://wearables.developer.meta.com/docs/develop/dat/ai-assisted-mcp/ before editing code. Inspect my iOS app first, then add the smallest working Device Access Toolkit integration slice: Info.plist setup, SDK package imports, Wearables.configure(), app registration launch, and connection lifecycle wiring. Call out bundle identifier, TeamID, URL scheme, MetaAppID, ClientToken, and local verification assumptions before making larger changes.
```

--------------------------------

### Install AGENTS.md for iOS SDK

Source: https://wearables.developer.meta.com/docs/develop/dat/ai-assisted-agents-md

Use this curl command to install the AGENTS.md file for the iOS SDK. It downloads and runs the installer script with the 'agents' argument.

```bash
curl -sL https://raw.githubusercontent.com/facebook/meta-wearables-dat-ios/main/install-skills.sh | bash -s -- agents

```

--------------------------------

### Install Copilot skills remotely for Android

Source: https://wearables.developer.meta.com/docs/develop/dat/ai-assisted-github-copilot

Installs the GitHub Copilot skills remotely for Android development using the provided installation script.

```bash
curl -sL https://raw.githubusercontent.com/facebook/meta-wearables-dat-android/main/install-skills.sh | bash -s copilot

```

--------------------------------

### Add Inputs capability to a started session with addInputs

Source: https://wearables.developer.meta.com/docs/develop/dat/inputs

Creates an InputsConfiguration with the desired sources and attaches it to a started session. addInputs returns nil if the session has not started and throws if an Inputs capability is already attached; a successful return begins activation, so wait for `.active` before relying on events.

```swift
let configuration = InputsConfiguration(sources: [.captouch, .neuralBand])
guard let inputs = try session.addInputs(configuration: configuration) else { return }

```

--------------------------------

### Run bundled installer for Muse Code

Source: https://wearables.developer.meta.com/docs/develop/dat/ai-assisted-muse

Bundled installer for SDK repos; requires 'muse' on PATH and runs the same three commands including the approve step.

```shell
./install-skills.sh muse
```

--------------------------------

### Install Device Access Toolkit plugin for Claude Code and Codex

Source: https://wearables.developer.meta.com/docs/develop/dat/build-integration-ios

Commands to add the meta-wearables-dat-ios plugin marketplace and install the mwdat-ios plugin for Claude Code and Codex. This enables AI coding tools to access iOS setup and Mock Device Kit guidance.

```bash
# Claude Code
claude plugin marketplace add facebook/meta-wearables-dat-ios
claude plugin install mwdat-ios@mwdat-ios-marketplace

# Codex
codex plugin marketplace add facebook/meta-wearables-dat-ios
codex plugin add mwdat-ios@mwdat-ios-marketplace
```

--------------------------------

### Install Device Access Toolkit plugin for Claude Code

Source: https://wearables.developer.meta.com/docs/develop/dat/getting-started-toolkit

Adds the Meta Wearables DAT plugin marketplace and installs the Android or iOS plugin for Claude Code. Run the Android commands for Android development and the iOS commands for iOS development. The plugin enables platform-specific setup, implementation, and Mock Device Kit testing workflows.

```bash
# Android
claude plugin marketplace add facebook/meta-wearables-dat-android
claude plugin install mwdat-android@mwdat-android-marketplace

# iOS
claude plugin marketplace add facebook/meta-wearables-dat-ios
claude plugin install mwdat-ios@mwdat-ios-marketplace
```

--------------------------------

### Start streaming and consume samples

Source: https://wearables.developer.meta.com/docs/develop/dat/motion

Start streaming and consume samples. samples is an AsyncStream, so iterate it in a task you retain and cancel during teardown. Store listener tokens as properties or in a ListenerTokenBag; an AnyListenerToken cancels when nothing references it. Attach both listeners before start() because neither publisher replays to new listeners. MotionError is non-frozen, so include an @unknown default branch. Handle each reading independently; Vector3 and Quaternion expose a simd property.

```swift
// Properties on the type that owns the capability, not local constants.
private var stateToken: AnyListenerToken?
private var errorToken: AnyListenerToken?
private var samplesTask: Task<Void, Never>?

stateToken = motion.statePublisher.listen { state in
  Task { @MainActor in
    // Update your UI for .starting, .started, .stopping, or .stopped
  }
}

errorToken = motion.errorPublisher.listen { error in
  Task { @MainActor in
    switch error {
    case .sensorUnavailable:
      showError(error)
    case .capabilityClosed, .deviceDisconnected:
      scheduleReattach()
    @unknown default:
      showError(error)
    }
  }
}

let samples = motion.samples
samplesTask = Task {
  for await sample in samples {
    if let acceleration = sample.accelerometer {
      await onAcceleration(acceleration.simd)
    }

    if let orientation = sample.orientation {
      await onOrientation(orientation.simd)
    }
  }
}

motion.start()

```

--------------------------------

### VideoPlayer usage for video playback

Source: https://wearables.developer.meta.com/docs/develop/dat/display-android

Play video from an HTTPS URL using VideoPlayer. The example shows creating a player, sending it to the display, starting playback, observing state, and closing the player. Constraints: MP4 only, max 400 pixels per side, 70,000 total pixels, one video at a time.

```kotlin
val player = VideoPlayer(
    source = VideoSource.Url("https://example.com/tutorial-clip.mp4"),
    codec = VideoCodec.MP4
)

// Send the video to the display
display.sendContent {
    video(player = player)
}

// Start video playback
player.play()

// Observe playback state
player.state.collect { state ->
    when (state) {
        VideoPlayerState.PLAYING -> { /* Video is playing */ }
        VideoPlayerState.ENDED -> { /* Video finished */ }
        VideoPlayerState.IDLE -> { /* Not started */ }
        VideoPlayerState.STARTING -> { /* Buffering */ }
        VideoPlayerState.PAUSE -> { /* Paused */ }
    }
}

// Stop playback
player.close()
```

--------------------------------

### Install Cursor skills locally

Source: https://wearables.developer.meta.com/docs/develop/dat/ai-assisted-cursor

Run this command from the SDK repo to install the .cursor rules locally. The .cursor directory is already included if you cloned the SDK repo.

```bash
./install-skills.sh cursor

```

--------------------------------

### Install repo-native skills for Copilot, Cursor, and agents

Source: https://wearables.developer.meta.com/docs/develop/dat/ai-assisted

Install repo-native skills for tools that use checked-in files instead of plugin manifests. Runs the install-skills.sh script for Copilot, Cursor, and agents.

```bash
./install-skills.sh copilot
./install-skills.sh cursor
./install-skills.sh agents

```

--------------------------------

### Start voice invocations stream with Wearables.startVoiceInvocationsStream

Source: https://wearables.developer.meta.com/docs/develop/dat/voice-invocations

Start the voice invocations stream and hold it in a property. The stream starts itself when created; there is no separate start() call. If automatic start fails, the failure is logged and surfaces on errors and state rather than throwing.

```kotlin
private lateinit var stream: VoiceInvocationsStream

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    stream = Wearables.startVoiceInvocationsStream(AutoDeviceSelector())
}
```

--------------------------------

### Install Copilot skills remotely for iOS

Source: https://wearables.developer.meta.com/docs/develop/dat/ai-assisted-github-copilot

Installs the GitHub Copilot skills remotely for iOS development using the provided installation script.

```bash
curl -sL https://raw.githubusercontent.com/facebook/meta-wearables-dat-ios/main/install-skills.sh | bash -s copilot

```

--------------------------------

### XCUITest client setup with MWDATMockDeviceTestClient

Source: https://wearables.developer.meta.com/docs/develop/dat/testing-mdk-ios

XCUITest setup that links MWDATMockDeviceTestClient, reads the server port from a temp file, and demonstrates pairing, configuring camera resources, controlling device state (don/doff/fold/unfold), and querying device state.

```swift
import MWDATMockDeviceTestClient
import XCTest

final class MyUITests: XCTestCase {
    var portFilePath: String {
        NSTemporaryDirectory() + "mwdat_test_server_port.txt"
    }
    private let app = XCUIApplication()
    private var mockClient: MockDeviceTestClient!
    private var deviceId: String?

    override func setUpWithError() throws {
        // Remove any stale port file from a previous run
        try? FileManager.default.removeItem(atPath: portFilePath)

        app.launchArguments = ["--ui-testing"]
        app.launchEnvironment["MWDAT_TEST_SERVER_PORT_FILE"] = portFilePath
        app.launch()

        // Initialize the client after launch so the server has time to write the port file
        mockClient = MockDeviceTestClient(portFilePath: portFilePath)
        XCTAssertTrue(mockClient.waitForServer(timeout: 10), "Test server should be running")
    }

    override func tearDownWithError() throws {
        if let deviceId {
            mockClient.unpairDevice(deviceId: deviceId)
        }
        deviceId = nil
    }

    func testStreaming() {
        // Pair a device — pairDevice() powers it on and dons it automatically
        guard let id = mockClient.pairDevice() else {
            XCTFail("Failed to pair mock device")
            return
        }
        deviceId = id

        // Configure camera resources for this device
        mockClient.setCameraFeed(deviceId: id, resourceName: "plant", ext: "mp4")
        mockClient.setCapturedImage(deviceId: id, resourceName: "plant", ext: "png")

        // Device is now paired, powered on, and donned
        let startButton = app.buttons["Start streaming"]
        XCTAssertTrue(startButton.waitForExistence(timeout: 15))

        // Control device state mid-test
        mockClient.doff(deviceId: id)   // device becomes inactive
        mockClient.don(deviceId: id)    // device becomes active again
        mockClient.fold(deviceId: id)   // hinges close, streaming stops
        mockClient.unfold(deviceId: id) // hinges open

        // Query device state
        let state = mockClient.getDeviceState()
        XCTAssertEqual(state?["pairedDeviceCount"] as? Int, 1)
    }
}

```

--------------------------------

### Add camera, subscribe to streams, and wait for startup (Kotlin)

Source: https://wearables.developer.meta.com/docs/develop/dat/camera-capture

Creates a camera and accesses its photo child, subscribes to errors, transferProgressStream, and photoStream, waits for subscriptions, then waits for the photo state to reach STARTED. Returns a pair of Camera and Photo, or null on failure.

```kotlin
private suspend fun startPhotoCapture(
    session: DeviceSession,
    scope: CoroutineScope,
): Pair<Camera, Photo>? {
    val camera = session.addCamera().getOrThrow()
    val photo = camera.photo

    val subscribed = CompletableDeferred<Unit>()
    val remaining = AtomicInteger(3)
    fun markSubscribed() {
        if (remaining.decrementAndGet() == 0) subscribed.complete(Unit)
    }

    scope.launch {
        photo.errors
            .onSubscription { markSubscribed() }
            .collect { error -> showError(error.description) }
    }
    scope.launch {
        photo.transferProgressStream
            .onSubscription { markSubscribed() }
            .collect { progress -> updateProgress(progress.fraction) }
    }
    scope.launch {
        photo.photoStream
            .onSubscription { markSubscribed() }
            .collect { data -> saveImage(data.imageData) }
    }
    subscribed.await()

    var sawStarting = false
    val outcome = withTimeoutOrNull(PHOTO_STARTUP_TIMEOUT_MS) {
        photo.state.first { state ->
            when (state) {
                PhotoState.STARTING -> { sawStarting = true; false }
                PhotoState.STARTED -> true
                // A return to STOPPED after STARTING is a setup failure.
                PhotoState.STOPPED -> sawStarting
                PhotoState.STOPPING -> false
            }
        }
    }

    if (outcome != PhotoState.STARTED) {
        camera.stop()
        return null
    }
    return camera to photo
}

```

--------------------------------

### Grounded camera and lifecycle implementation prompt

Source: https://wearables.developer.meta.com/docs/develop/dat/ai-assisted-claude-code

Prompt for grounded implementation: use the plugin for platform guidance, then query search_dat_docs for current documentation. Instructs Claude to inspect the project, make minimal changes, and run local checks.

```text
Use the installed Device Access Toolkit plugin for platform-specific implementation guidance. Then ask search_dat_docs for current camera streaming and session lifecycle guidance. Inspect my project first, make the smallest safe change, and run the relevant local checks.

```

--------------------------------

### Install AGENTS.md for Android SDK

Source: https://wearables.developer.meta.com/docs/develop/dat/ai-assisted-agents-md

Use this curl command to install the AGENTS.md file for the Android SDK. It downloads and runs the installer script with the 'agents' argument.

```bash
curl -sL https://raw.githubusercontent.com/facebook/meta-wearables-dat-android/main/install-skills.sh | bash -s -- agents

```

--------------------------------

### Install Cursor compatibility file for Android SDK

Source: https://wearables.developer.meta.com/docs/develop/dat/ai-assisted-agents-md

Use this curl command to install the Cursor compatibility file for the Android SDK. It downloads and runs the installer script with the 'cursor' argument.

```bash
curl -sL https://raw.githubusercontent.com/facebook/meta-wearables-dat-android/main/install-skills.sh | bash -s -- cursor

```

--------------------------------

### Muse Code: Verify first-app prerequisites with Device Access Toolkit plugin

Source: https://wearables.developer.meta.com/docs/develop/dat/ai-assisted-mcp

Use the installed Device Access Toolkit plugin for platform-specific implementation guidance. Then ask search_dat_docs what to install and check before building the first Device Access Toolkit app.

```text
Use the installed Device Access Toolkit plugin for platform-specific implementation guidance. Then ask search_dat_docs what I should install and check before building my first Device Access Toolkit app.
```
Tokens:
Raw