Session Lifecycle Agent Skill

Session Lifecycle (iOS)

Guide for managing device session states in DAT SDK integrations.

Overview

The DAT SDK runs work inside sessions. Meta glasses expose two experience types:

• Device sessions — sustained access to device sensors and outputs
• Transactions — short, system-owned interactions (notifications, "Hey Meta")

Your app observes session state changes — the device decides when to transition.

Session states

| State | Meaning | App action |

|-------|---------|------------|

| idle | Session created but not started | Call start() when ready |

| starting | Session is connecting to the device | Show connecting state |

| started | Session active and ready for capabilities | Add or resume work |

| paused | Temporarily suspended by the device | Hold work, may resume |

| stopping | Session is cleaning up | Wait for terminal state |

| stopped | Session inactive and terminal | Free resources, create a new session to restart |

Observing session state

let session = try Wearables.shared.createSession(deviceSelector: AutoDeviceSelector(wearables: Wearables.shared))
try session.start()

Task {
    for await state in session.stateStream() {
        switch state {
        case .started:
            // Confirm UI shows session is live
        case .paused:
            // Keep connection, wait for started or stopped
        case .stopped:
            // Release resources, allow user to restart
        default:
            break
        }
    }
}

Stream state transitions

A Stream is obtained from the Camera capability attached to a started DeviceSession:

stopped → waitingForDevice → starting → streaming → paused → stopped

guard let camera = try session.addCamera(config: StreamConfiguration()) else { return }
let stream = camera.stream

let token = stream.statePublisher.listen { state in
    Task { @MainActor in
        // React to state changes
    }
}

Common transitions

The device changes session state when:

• User performs a system gesture that opens another experience
• Another app starts a device session
• User removes or folds the glasses (Bluetooth disconnects)
• User removes the app from Meta AI companion app
• Connectivity between companion app and glasses drops

Pause and resume

When a session is paused:

• The device keeps the connection alive
• Streams stop delivering data
• The device may resume by returning to started

Your app should not attempt to restart while paused — wait for started or stopped.

Device availability

Monitor device availability to know when sessions can start:

Task {
    for await devices in Wearables.shared.devicesStream() {
        // Update list of available glasses
    }
}

Key behaviors:

• Closing hinges disconnects Bluetooth → forces stopped
• Opening hinges restores Bluetooth but does not restart sessions
• Start a new session after the device becomes available again

Implementation checklist

• [ ] Handle all relevant session states (started, paused, stopped)
• [ ] Monitor device availability before starting work
• [ ] Release resources only after stopped
• [ ] Don't infer transition causes — rely only on observable state
• [ ] Don't restart during paused — wait for system to resume or stop

Links

• Session lifecycle documentation