adapter_js.go

package bluetooth

import (
	"errors"
	"syscall/js"
)

var _ BLEAdapter = (*Adapter)(nil)

var errNotEnabled = errors.New("bluetooth: adapter is not enabled, call Enable first")

// Adapter represents the WebBluetooth adapter accessed via navigator.bluetooth.
type Adapter struct {
	bluetooth      js.Value
	connectHandler func(device Device, connected bool)

	// devices holds the BluetoothDevice objects returned by Scan, keyed by
	// device ID, because Connect needs them again.
	devices map[string]js.Value

	// disconnectListeners holds the gattserverdisconnected listeners, keyed
	// by device ID.
	disconnectListeners map[string]js.Func

	// notifying holds the characteristics that have a value change listener.
	notifying map[*deviceCharacteristic]struct{}

	scanning bool

	// RequestedServices is the list of service UUIDs to give as
	// optionalServices to navigator.bluetooth.requestDevice().
	//
	// The browser refuses access to a service that is not in this list. Set
	// this before you call Scan.
	RequestedServices []UUID
}

// DefaultAdapter is the default adapter using the navigator.bluetooth API.
//
// Make sure to call Enable() before using it to initialize the adapter.
var DefaultAdapter = &Adapter{
	connectHandler: func(device Device, connected bool) {},
}

// Enable configures the BLE stack. It must be called before any
// Bluetooth-related calls (unless otherwise indicated).
func (a *Adapter) Enable() error {
	navigator := js.Global().Get("navigator")
	if navigator.IsUndefined() {
		return errors.New("bluetooth: navigator is not available")
	}

	// navigator.bluetooth only exists in a secure context.
	// https://webbluetoothcg.github.io/web-bluetooth/#navigator-extensions
	if secure := js.Global().Get("isSecureContext"); secure.Type() == js.TypeBoolean && !secure.Bool() {
		return errors.New("bluetooth: WebBluetooth needs a secure context, such as HTTPS or localhost")
	}

	bt := navigator.Get("bluetooth")
	if bt.IsUndefined() {
		return errors.New("bluetooth: WebBluetooth is not supported in this browser")
	}

	// This is false without an adapter, or when a policy blocks WebBluetooth.
	// https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetooth-getavailability
	available, err := await(bt.Call("getAvailability"))
	if err != nil {
		return err
	}
	if !available.Truthy() {
		return errors.New("bluetooth: no adapter, or the browser blocks WebBluetooth")
	}
	a.bluetooth = bt

	// Keep the known devices when Enable runs more than once.
	if a.devices == nil {
		a.devices = map[string]js.Value{}
		a.disconnectListeners = map[string]js.Func{}
		a.notifying = map[*deviceCharacteristic]struct{}{}
	}
	return nil
}

// Reset clears the state of the adapter so that Enable can run again.
//
// The devices from an earlier scan are gone after this, so the user must
// select a device again.
func (a *Adapter) Reset() error {
	// Remove the listeners before the disconnect, so that no event arrives
	// after the release of the JS function.
	for c := range a.notifying {
		c.stopListening()
	}
	for id, listener := range a.disconnectListeners {
		if device, ok := a.devices[id]; ok {
			device.Call("removeEventListener", "gattserverdisconnected", listener)
		}
		listener.Release()
	}

	// The browser keeps the connection until the page closes it.
	for _, device := range a.devices {
		gatt := device.Get("gatt")
		if !gatt.IsUndefined() && gatt.Get("connected").Bool() {
			gatt.Call("disconnect")
		}
	}

	a.bluetooth = js.Undefined()
	clear(a.devices)
	clear(a.disconnectListeners)
	a.scanning = false
	return nil
}