Manage session and stream state with pause, resume, and device monitoring.
The material indicates a prompt/documentation-only skill with no required secrets, no declared remote endpoints, and no executable installation steps, so overall risk is low. Combined with an open-source GitHub source and some community adoption, no clear high-risk red flags are present, though the runtime capabilities of the underlying Android/DAT SDK should still be assessed in the host app context.
The material explicitly states that no keys or environment variables are required. The README only describes session lifecycle and state observation, with no mention of tokens, API keys, or credential storage/handling, so no direct credential exposure or abuse surface is evident.
No remote endpoints are declared. While the documentation mentions device connection, Bluetooth drops, and developer documentation links, the skill material itself does not describe sending user data to third-party services, and no unrelated or unknown destinations are identified.
The system checks mark this as prompt-only. The README provides only Kotlin examples and state-machine guidance, with no installation scripts, command execution, process spawning, or requests for additional system execution privileges.
The material does not declare read/write access to local files, databases, the clipboard, or other user data sources. It only discusses session state, stream state, and device availability monitoring, with no sign of data access beyond its described purpose.
The source is an open-source GitHub repository with 289 stars, providing auditability and some community adoption, which are clear risk-reducing factors. However, the license is unspecified, maintenance status is unknown, and the referenced repository name does not perfectly match the skill name, so users should verify repository relevance and recent maintenance before adoption.
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-android/main/plugins/mwdat-android/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 session lifecycle for a real-time voice AI app, including session creation, stream start, pause, resume, end, and interruption handling. Output a state machine description.
A clear session state machine defining states, triggers, and error-handling logic.
Create a pause/resume strategy for a real-time stream when the user backgrounds the app, network becomes unstable, or manual pause is triggered, including state sync, reconnection, and user messaging.
A pause/resume handling plan covering state retention, resume conditions, reconnection steps, and suggested user messages.
Design a device availability monitoring approach for a session system using microphone and camera, explaining how to update session and stream state when devices disconnect, permissions change, or users switch devices.
A device monitoring and state update plan for reliably handling permissions, disconnects, and device-switch events.
Manage session and stream state in DAT SDK integrations.
Create a Session with Wearables.createSession(...), start it, then attach capabilities such as camera streaming. Session lifecycle and stream lifecycle are related but distinct.
| State | Meaning | App action |
|---|---|---|
IDLE | Session created, not started yet | Call session.start() |
STARTING | Connecting to the device | Show loading UI |
STARTED | Session active and ready for capabilities | Add or use capabilities |
PAUSED | Session temporarily suspended | Keep state, wait for resume or stop |
STOPPING | Session is shutting down | Stop user work and wait |
STOPPED | Session ended | Release resources and create a new session if needed |
val session = Wearables.createSession(AutoDeviceSelector()).getOrElse { error ->
throw IllegalStateException(error.description)
}
session.start()
lifecycleScope.launch {
session.state.collect { state ->
when (state) {
DeviceSessionState.STARTED -> onStarted()
DeviceSessionState.PAUSED -> onPaused()
DeviceSessionState.STOPPED -> onStopped()
else -> Unit
}
}
}
Camera streaming has its own state flow after you attach a stream:
STOPPED -> STARTING -> STARTED -> STREAMING -> STOPPING -> STOPPED -> CLOSED
lifecycleScope.launch {
stream.state.collect { state ->
// React to camera capability state changes
}
}
The SDK may pause or stop a session when:
When a session is paused:
lifecycleScope.launch {
Wearables.devices.collect { devices ->
// Update the list of available devices
}
}
Use Wearables.devices and device metadata to decide when it is sensible to create a new session after a stop.
DeviceSessionState values you care aboutSessionError and StreamError failuresSet up camera sessions, stream video, capture photos, and tune resolution.
Build a complete DAT app with sessions, camera streaming, and photo capture.
Diagnose common issues, compatibility problems, and session or stream debugging cases.
Helps developers set up Meta AI app registration and device permission flows.
Build display-enabled interfaces with device selection, UI components, and media playback.
Learn Kotlin conventions, result handling, and session patterns for DAT SDK Android.
Manage device session states, pause and resume flows, and availability monitoring.
Diagnose misconfigurations, failures, and unexpected behavior in the current Amplifier session.
Build a streamable HTTP MCP server template with TypeScript and session management.
Test XR session lifecycle and mode transitions to verify behavior and debug state issues.
Build custom video session apps with full control using Zoom Video SDK
Keep MCP sessions alive across ECS Fargate deployments with Redis-backed state.