Build a Bluetooth chat for iOS and Android

git clone https://github.com/holepunchto/bare-mobile-doctor
cd bare-mobile-doctor
npm install
npm run link
npm run bundle

npm run ios
npm run android

npx expo run:android --variant release --no-bundler

adb -s <serial> install -r android/app/build/outputs/apk/release/app-release.apk

const ipc = new FramedStream(BareKit.IPC)

const central = new BLECentral({ serviceUUID: SERVICE_UUID, psmUUID: PSM_UUID })
const server = new BLEServer({ serviceUUID: SERVICE_UUID, psmUUID: PSM_UUID })

const session = new Session({
  central,
  server,
  deviceName: Bare.argv[0] || 'BareDevice',
  send: (msg) => ipc.write(Buffer.from(JSON.stringify(msg)))
})

    this._central.on('stateChange', (bleState) => {
      dbg('Central: stateChange', bleState)
      this.emit('stateChange', bleState)
      if (bleState === 'poweredOn') {
        this.emit('ready')
        if (this.scanning === ToggleState.REQUESTED) this.startScan()
      }
    })

  _start() {
    if (this._server.state !== 'poweredOn') return
    if (!this.serviceAdded) {
      this._server.addService(new Service(this.serviceUUID, [this.psmChar]))
    }
    if (this._psm == null) this._server.publishChannel()
  }

const SERVICE_UUID = 'B4A3C8A7-0000-1000-8000-00805F9B34FB'
// Readable characteristic that carries the L2CAP PSM the server published, so a
// central can learn where to open the connection-oriented channel.
const PSM_UUID = 'B4A3C8A7-0003-1000-8000-00805F9B34FB'
const CONNECT_TIMEOUT_MS = 15000

const isAndroid = Bare.platform === 'android'
const scanOptions = isAndroid ? { scanMode: Central.SCAN_MODE_LOW_LATENCY } : undefined

    this._server.on('channelPublish', (psm) => {
      dbg('Server: channelPublish psm=', psm)
      this._psm = psm
      this.emit('log', `L2CAP channel published psm=${psm}`)
      if (this.advertising === ToggleState.REQUESTED) this.startAdvertising()
    })

    this._server.on('channelOpen', (channel) => {
      dbg('Server: channelOpen (invitee side)')
      this.emit('log', 'L2CAP channel open')
      this.emit('link', new PeerLink(channel))
    })

    // A central reads this to discover the PSM before opening the channel. The
    // PSM is a plain number, so send it as raw text (not JSON) - the central
    // parses it with Number().
    this._server.on('readRequest', (req) => {
      dbg('Server: readRequest (PSM) psm=', this._psm)
      const value = this._psm != null ? Buffer.from(String(this._psm)) : Buffer.alloc(0)
      this._server.respondToRequest(req, Server.ATT_SUCCESS, value)
    })

  startAdvertising(deviceName) {
    if (deviceName !== undefined) this._deviceName = deviceName
    if (this.advertising === ToggleState.ON) return

    if (this._server.state !== 'poweredOn') {
      this.emit('log', 'Advertising is waiting for Bluetooth power')
      return
    }

    // Both the GATT service (for PSM discovery) and the published PSM must be
    // ready before we invite centrals to connect.
    if (!this.serviceAdded || this._psm == null) {
      this._start()
      this.advertising = ToggleState.REQUESTED
      this.emit('log', 'Advertising is waiting for service and PSM')
      return
    }

    const opts = { serviceUUIDs: [this.serviceUUID] }
    if (this._deviceName) opts.name = this._deviceName

    this.emit('log', `Starting advertising: ${this.serviceUUID}`)
    this._server.startAdvertising(opts)
    this.advertising = ToggleState.ON
    this.emit('advertisingStarted')
  }

  startScan() {
    if (this.scanning === ToggleState.ON) return

    if (this._central.state !== 'poweredOn') {
      this.emit('log', 'Scan is waiting for Bluetooth power')
      return
    }

    this._central.startScan([this.serviceUUID], scanOptions)
    this.scanning = ToggleState.ON
    this.emit('scanStarted')
  }

    this._central.on('discover', (discovered) => {
      this.discoveredPeripherals.set(discovered.id, discovered)

      let name = discovered.name
      if (!name && discovered.serviceData && discovered.serviceData[this.serviceUUID]) {
        name = Buffer.from(discovered.serviceData[this.serviceUUID]).toString()
      }

      this.emit('discovered', { id: discovered.id, name: name || 'Unknown', rssi: discovered.rssi })
    })

  connect(id) {
    const discovered = this.discoveredPeripherals.get(id)
    if (!discovered) {
      this.emit('error', 'Device not found: ' + id)
      return false
    }

    if (this.scanning !== ToggleState.OFF) this.stopScan()

    this.emit('log', `Connecting to: ${discovered.name || discovered.id || 'unknown'}`)
    this._central.connect(discovered)
    return true
  }

  _onConnect(peripheral) {
    this.peripheral = peripheral
    this.emit('log', `Connected: ${peripheral.name || peripheral.id || 'unknown'}`)

    peripheral.on('servicesDiscover', (services) => {
      dbg('Central: servicesDiscover', services && services.length)
      const service = findByUUID(services, this.serviceUUID)
      if (!service) {
        this.emit('error', 'Chat service not found')
        this.emit('connectFailed')
        return
      }
      peripheral.discoverCharacteristics(service, [this.psmUUID])
    })

    peripheral.on('characteristicsDiscover', (service, chars) => {
      dbg('Central: characteristicsDiscover', chars && chars.length)
      const psmChar = findByUUID(chars, this.psmUUID)
      if (!psmChar) {
        this.emit('error', 'PSM characteristic not found')
        this.emit('connectFailed')
        return
      }
      this.emit('log', 'Reading L2CAP PSM')
      peripheral.read(psmChar)
    })

    peripheral.on('read', (char, data) => {
      const text = Buffer.from(data).toString()
      dbg('Central: read PSM char ->', JSON.stringify(text))
      const psm = Number(text)
      if (!psm) {
        this.emit('error', `Invalid PSM: ${JSON.stringify(text)}`)
        this.emit('connectFailed')
        return
      }
      this.emit('log', `Opening L2CAP channel psm=${psm}`)
      peripheral.openL2CAPChannel(psm)
    })

    peripheral.on('channelOpen', (channel) => {
      dbg('Central: channelOpen (inviter side)')
      this.emit('log', 'L2CAP channel open')
      this.emit('link', new PeerLink(channel))
    })

    peripheral.on('error', (err) => {
      dbg('Central: peripheral error', err && err.message)
      this.emit('error', err.message || String(err))
      this.emit('connectFailed')
    })

    this.emit('log', 'Discovering services')
    peripheral.discoverServices([this.serviceUUID])
  }

function normalizeUUID(uuid) {
  return String(uuid || '')
    .toLowerCase()
    .replace(/-/g, '')
}

function matchesUUID(a, b) {
  return normalizeUUID(a) === normalizeUUID(b)
}

function findByUUID(items, uuid) {
  if (!items) return null
  for (const item of items) {
    if (matchesUUID(item.uuid, uuid)) return item
  }
  return null
}

// A framed, bidirectional message channel over an L2CAP Duplex. Both peers use
// the same object: once the channel is open there is no central/server
// asymmetry, so the chat protocol runs identically on either side.
class PeerLink extends EventEmitter {
  constructor(channel) {
    super()
    dbg('PeerLink: new (wrapping L2CAP channel in FramedStream)')
    this._stream = new FramedStream(channel)

    this._stream.on('data', (data) => {
      dbg('PeerLink: data', data.byteLength, 'bytes')
      let msg
      try {
        msg = JSON.parse(Buffer.from(data).toString())
      } catch (e) {
        this.emit('error', `Bad BLE data (${data.byteLength} bytes)`)
        return
      }
      this.emit('message', msg)
    })

    // L2CAP is reliable: a peer leaving surfaces as end/close/error on the
    // stream, so we don't need platform-specific disconnect detection.
    this._stream.on('close', () => {
      dbg('PeerLink: stream close')
      this.emit('close')
    })
    this._stream.on('error', (err) => {
      dbg('PeerLink: stream error', err && err.message)
      this.emit('close')
    })
  }

  send(msg) {
    dbg('PeerLink: send', msg.t)
    this._stream.write(serialize(msg))
  }

  close() {
    dbg('PeerLink: close()')
    this._stream.destroy()
  }
}

    this._central.on('error', (err) => {
      dbg('Central: error', err && err.code, err && err.message)
      this.emit('error', err.message || String(err))

      // iOS & Android report errored connects/disconnects as 'error' (not
      // 'disconnect'), so route the codes or the session stays stuck connected.
      if (err && err.code === 'CONNECTION_FAILED') {
        this.emit('connectFailed')
      } else if (err && err.code === 'DISCONNECT') {
        this.emit('closed')
      }
    })

  startConnectTimeout() {
    this.clearConnectTimeout()
    this.state.connectTimer = setTimeout(() => {
      this.state.connectTimer = null
      if (this.state.inviteRole !== 'inviter' || this.state.link) return

      this.teardown()
      this.send({ type: 'error', message: 'Connection timed out' })
      this.send({ type: 'disconnected' })
      this.central.setScan(true)
    }, CONNECT_TIMEOUT_MS)
  }

  // Close the link and drop any BLE connection we opened. Safe to call from any
  // role: central.disconnect() is a no-op when we never connected.
  teardown() {
    dbg('Session: teardown (role=' + this.state.inviteRole + ')')
    if (this.state.link) {
      this.state.link.close()
      this.state.link = null
    }
    this.central.disconnect()
    this.state.inviteRole = 'idle'
  }

    return () => {
      const stream = streamRef.current
      const worklet = workletRef.current
      streamRef.current = null

      // Tell the peer we're leaving so it tears down cleanly instead of waiting
      // for the BLE supervision timeout, then give the worklet a moment to write
      // the disconnect over the air before terminating it.
      try {
        stream?.write(b4a.from(JSON.stringify({ type: 'disconnect' })))
      } catch {}

      setTimeout(() => worklet?.terminate(), 150)
    }

  // We only release our own state here (connect timer + L2CAP link). We should
  // also call server.destroy()/central.destroy() to own their teardown, but the
  // native module's on_cleanup double-frees the same V8 handle at runtime
  // teardown and crashes (EXC_BAD_ACCESS in central__on_cleanup).
  // TODO: restore server.destroy()/central.destroy() once bare-bluetooth-apple
  // makes on_cleanup idempotent w.r.t. an explicit destroy().
  destroy() {
    dbg('Session: destroy')
    this.clearConnectTimeout()
    if (this.state.link) {
      this.state.link.close()
      this.state.link = null
    }
  }