Start with the contract
Review the shared frame and transport types before writing adapter code.
Check browser support
Confirm Web Bluetooth, browser, and platform constraints first.
What You Are Building
A production-ready integration should do three things well:- connect reliably
- stream frames in a stable, predictable format
- recover cleanly when the device, browser, or radio link misbehaves
HeadbandTransport and
HeadbandFrameV1 instead of exposing vendor-specific packet layouts directly.
Apps should depend on the shared Elata transport contract, not on raw vendor
packets. That keeps downstream integrations simple and makes device support
easier to maintain.
The Fast Path
Choose an integration path
Decide whether your device belongs upstream in
eeg-web-ble, in a separate
package, or in an app-local adapter. Use
Integration Paths to make that decision early.Capture the protocol inventory
Gather your GATT services, characteristics, packet format, sample rate,
channel names, timestamp behavior, and known firmware quirks. See
Protocol Requirements.
Implement the adapter
Build the device layer that handles discovery, session setup, packet
decoding, and frame emission. Start from
Adapter Implementation.
Validate for reliability
Test connect, start, stop, disconnect, malformed packets, reconnects, and
frame correctness before tuning anything downstream. Use
Testing and Validation.
Prepare the handoff
Package the integration with platform notes, tested firmware versions, and
support expectations. See Submission and Support.
What You Need Before You Start
| Requirement | Why it matters |
|---|---|
| Device protocol details | You need a complete byte-level picture before implementation starts. |
| A supported browser path | Web Bluetooth requires Chrome or Edge in a secure context. |
| Stable channel metadata | Apps need consistent channel order, names, and sample rates. |
| A clear ownership model | Decide early whether this will live upstream, in a vendor package, or privately. |
Guide Map
Integration Paths
Choose where the integration should live and how it should be owned.
Transport Contract
The shared interfaces your device must satisfy.
Protocol Requirements
The protocol and metadata inventory to collect before coding.
Adapter Implementation
Build the device adapter and connect it to
BleTransport.Testing and Validation
Make the integration reliable under normal and failure conditions.
Submission and Support
Hand off the integration with the docs and caveats partners need.
Reliability First
A device integration is not done when it streams once on a happy path. It is done when:| Done means | Notes |
|---|---|
connect() is predictable | discovery and session setup succeed or fail clearly |
start() produces stable frames | row width, channel order, and sample rate stay correct |
stop() is clean | the session stops without leaving the device in a bad state |
disconnect() is clean | the browser session releases resources correctly |
| failures are surfaced clearly | apps can react to disconnects, retries, and unsupported states |
Related Docs
Next
Choose an integration path
Pick the right ownership and packaging model before coding.
Review the transport contract
Confirm the frame and lifecycle expectations your adapter must satisfy.