$ loading_
Manage device session states, pause and resume flows, and availability monitoring.
The material indicates an open-source, prompt/documentation-style iOS integration guide with no declared secrets, remote endpoints, or extra system permissions. Overall risk is low based on the provided facts, though supply-chain trust should still be manually checked because the repository has 0 stars and unknown maintenance status.
The material and stated checks show no required secrets or environment variables. No token, API key, or account credential handling is described, so credential leakage or misuse risk appears low.
No remote endpoints are declared. The content mainly describes device session states, Bluetooth connectivity changes, and local SDK usage, with no indication of sending user data to third-party services.
The system marks it as prompt-only, and the material contains only Swift examples and integration guidance. There is no sign of spawning local processes, running scripts, or requesting execution privileges beyond the stated purpose.
The feature centers on device sessions, available device lists, and stream states, which typically involve access to device status and sensor/stream-related data as a normal SDK capability. No clear red flags are shown for filesystem access, bulk collection, or excessive permissions, but the actual iOS permissions and reachable data scope should still be verified during integration.
The source is an open-source GitHub repository, which is a positive factor for auditability. However, the license is undeclared, community adoption is 0 stars, and maintenance status is unknown, which weakens supply-chain trust. This is not enough to classify as high risk, but the repo ownership, commit history, and dependencies should be reviewed before use.
Copy the install command and let the AI configure it · recommended for beginners
Please install the "session-lifecycle" skill from askskill: 1. Download https://raw.githubusercontent.com/facebook/meta-wearables-dat-ios/main/plugins/mwdat-ios/skills/session-lifecycle/SKILL.md 2. Save it as ~/.claude/skills/session-lifecycle/SKILL.md 3. Reload skills and tell me it's ready
Design a state machine for device sessions including init, active, paused, resumed, disconnected, and timed-out states, and explain triggers and recovery strategies for each state.
A clear session state machine spec with state definitions, transition conditions, and exception handling guidance.
Help me define pause and resume logic for device sessions, including manual pause, auto-pause on network interruption, retry behavior after resume, and a way to avoid duplicate task execution.
An implementable pause-resume flow covering trigger rules, retry strategy, and idempotency handling.
Provide an availability monitoring plan for device sessions, including heartbeat checks, offline thresholds, alert rules, and key metrics suitable for an operations dashboard.
A session availability monitoring plan with metrics, alert conditions, and dashboard display recommendations.
Guide for managing device session states in DAT SDK integrations.
The DAT SDK runs work inside sessions. Meta glasses expose two experience types:
Your app observes session state changes — the device decides when to transition.
| 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 |
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
}
}
}
A Stream is a capability attached to a started DeviceSession:
stopped → waitingForDevice → starting → streaming → paused → stopped
guard let stream = try session.addStream(config: StreamConfiguration()) else { return }
let token = stream.statePublisher.listen { state in
Task { @MainActor in
// React to state changes
}
}
The device changes session state when:
When a session is paused:
startedYour app should not attempt to restart while paused — wait for started or stopped.
Monitor device availability to know when sessions can start:
Task {
for await devices in Wearables.shared.devicesStream() {
// Update list of available glasses
}
}
Key behaviors:
stoppedstarted, paused, stopped)stoppedpaused — wait for system to resume or stopBuild a complete DAT app with camera streaming and photo capture.
Learn Swift conventions, naming, and async patterns for DAT SDK iOS development.
Stream camera video, capture frames or photos, and configure resolution and frame rate.
Identify common bugs, version conflicts, and state machine failures faster.
Guide app registration with Meta AI and camera permission request flows.
Set up the Meta glasses SDK and make your first connection.
Manage session and stream state with pause, resume, and device monitoring.
Diagnose misconfigurations, failures, and unexpected behavior in the current Amplifier session.
Set up camera sessions, stream video, capture photos, and tune resolution.
Coordinate multiple Claude sessions across machines with shared state management.
Diagnose common issues, compatibility problems, and session or stream debugging cases.
Test XR session lifecycle and mode transitions to verify behavior and debug state issues.