Device access is powerful

When a website requests access to devices using requestDevice, it gets the ability to access all GATT services mentioned in the call. The UA MUST inform the user what capabilities these services give the website before asking which devices to entrust to it. If any services in the list aren't known to the UA, the UA MUST assume they give the site complete control over the device and inform the user of this risk. The UA MUST also allow the user to inspect what sites have access to what devices and revoke these pairings.

The UA MUST NOT allow the user to pair entire classes of devices with a website. It is possible to construct a class of devices for which each individual device sends the same Bluetooth-level identifying information. UAs are not required to attempt to detect this sort of forgery and MAY let a user pair this pseudo-device with a website.

To help ensure that only the entity the user approved for access actually has access, this specification requires that only secure contexts can access Bluetooth devices (requestDevice).

Global Bluetooth device properties

The physical Bluetooth device may be guaranteed to have some properties that the UA may not have received. Those properties are described as optional here.

A Bluetooth device has the following properties. Optional properties are not present, and sequence and map properties are empty, unless/until described otherwise. Other properties have a default specified or are specified when a device is introduced.

• A set of supported physical transports, including one or both of BR/EDR and LE. This set will generally be filled based on the transports over which the device was discovered and the Flags Data Type in the Advertising Data or Extended Inquiry Response.
• One or more of several kinds of 48-bit address: a Public Bluetooth Address, a (random) Static Address, and a resolvable or non-resolvable Private Address.
• An optional 128-bit Identity Resolving Key.
• An optional partial or complete Bluetooth Device Name. A device has a partial name when the Shortened Local Name AD data was received, but the full name hasn't been read yet.
• An ATT Bearer, over which all GATT communication happens. The ATT Bearer is created by procedures described in "Connection Establishment" under GAP Interoperability Requirements. It is disconnected in ways [[BLUETOOTH42]] isn't entirely clear about.
• A bonded flag, indicating whether the Bluetooth device is bonded to the UA. Devices bond using the Bonding Procedure.

  The Bluetooth standard uses "pairing" to refer to creating and exchanging a shared secret, and "bonding" to refer to storing that secret for use in subsequent connections. Platform APIs don't give independent control of the two processes, and they present the combined process to users under the label "pairing", so this specification uses "pairing" and "bonding" interchangeably to refer to Bluetooth bonding.

• The following optional elements from Advertising Data or the Extended Inquiry Response:
  • A list of advertised Service UUIDs.
  • Manufacturer Specific Data, consisting of a map from 16-bit Company Identifier Codes to byte arrays. This is treated as an empty map if it's not present.
  • A TX Power Level, from -127dBm to 127dBm.
  • Service Data, consisting of a map from UUIDs to byte arrays. This is treated as an empty map if it's not present.
  • An Appearance, one of the values defined by the org.bluetooth.characteristic.gap.appearance characteristic.
  • A Received Signal Strength Indication (RSSI), from -127dBm to 20dBm. This is received from the local Bluetooth adapter rather than being sent by the remote device.
• An optional Class of Device, one of the values defined in [[!BLUETOOTH-ASSIGNED-BASEBAND]]. The Class of Device is only used over the BR/EDR physical transport, not LE.
• A hierarchy of GATT attributes, described in .

The UA SHOULD determine that two Bluetooth devices are the same device if and only if they have the same Public Bluetooth Address, Static Address, Private Address, or Identity Resolving Key, or if the Resolvable Private Address Resolution Procedure succeeds using one device's IRK and the other's Resolvable Private Address. However, because platform APIs don't document how they determine device identity, the UA MAY use another procedure.

Per-origin Bluetooth device properties

For each origin, the UA MUST maintain an allowed devices map, whose keys are the Bluetooth devices the origin is allowed to access, and whose values are pairs of a DOMString device id and an allowed services list consisting of UUIDs for GATT Primary Services the origin is allowed to access on the device.

The UA MAY remove devices from the allowed devices map at any time based on signals from the user. This needs a definition involving removing BluetoothDevice instances from device instance maps and clearing out their [[\representedDevice]] fields. For example, if the user chooses not to remember access, the UA might remove a device when the tab that was granted access to it is closed. Or the UA might provide a revocation UI that allows the user to explicitly remove a device even while a tab is actively using that device. If a device is removed from this list while a Promise is pending to do something with the device, it MUST be treated the same as if the device moved out of Bluetooth range.

To add an allowed Bluetooth device device to an origin's allowed devices map with an optional allowed services list of UUIDs, the UA MUST run the following steps.

1. If device is the same device as an existing key in the allowed devices map, abort these steps.
2. Let id be a new DOMString that isn't equal to any of the device ids in the origin's allowed devices map and isn't equal to or derived from any of device's Public Bluetooth Address, Static Address, or Identity Resolving Key. id MUST, with very high probability, be unequal to the device ids used for keys in any other origin's allowed devices map or previously in this origin's allowed devices map that are the same device as device.
3. If allowed services wasn't provided, set it to an empty list.
4. Add a mapping from device to a pair of id and allowed services in the allowed devices map.

BluetoothDevice

A BluetoothDevice instance represents a Bluetooth device inside a particular script execution environment.

          // Allocation authorities for Vendor IDs:
          enum VendorIDSource {
            "bluetooth",
            "usb"
          };

          interface BluetoothDevice {
            readonly attribute DOMString id;
            readonly attribute DOMString? name;
            readonly attribute BluetoothAdvertisingData adData;
            readonly attribute unsigned long? deviceClass;
            readonly attribute VendorIDSource? vendorIDSource;
            readonly attribute unsigned long? vendorID;
            readonly attribute unsigned long? productID;
            readonly attribute unsigned long? productVersion;
            readonly attribute boolean paired;
            readonly attribute BluetoothGATTRemoteServer? gattServer;
            readonly attribute UUID[] uuids;
            Promise<BluetoothGATTRemoteServer> connectGATT();
          };
          BluetoothDevice implements EventTarget;
          BluetoothDevice implements CharacteristicEventHandlers;
          BluetoothDevice implements ServiceEventHandlers;
        

For each script execution environment, the UA must maintain a device instance map mapping Bluetooth devices to Promise<BluetoothDevice> instances. To get the BluetoothDevice representing a Bluetooth device device, the UA MUST run the following steps:

1. If there is a key in the current script execution environment's device instance map that is the same device as device, return its value and abort these steps.
2. Let promise be a new promise.
3. Add a mapping from device to promise in the current script execution environment's device instance map.
4. Return promise, and run the following steps in parallel.
   1. Let result be a new instance of BluetoothDevice.
   2. Initialize all of result's optional fields to null.
   3. Initialize an internal result@[[\representedDevice]] field to device.
   4. Find the key in this origin's allowed devices map that is the same device as device. If there is no such key, resolve promise with a SecurityError and abort these steps. Otherwise, initialize result.id to the device id this key maps to, and initialize an internal result@[[\allowedServices]] field to the allowed services list this key maps to.
   5. If device has a partial or complete Bluetooth Device Name, set result.name to that string.
   6. Create a BluetoothAdvertisingData from device and result@[[\allowedServices]], and set result.adData to the result.
   7. If device has a Class of Device, set result.deviceClass to that value.
   8. Populate the Bluetooth cache with the org.bluetooth.characteristic.pnp_id characteristic inside the org.bluetooth.service.device_information service. Ignore any errors from this step.
   9. If the Bluetooth cache now has a known-present entry for this characteristic, run the following substeps.
      1. Use any combination of the sub-procedures in the Characteristic Value Read procedure to retrieve the value of the org.bluetooth.characteristic.pnp_id characteristic into pnp. Handle errors as described in .
      2. If the previous step returned an error, abort these substeps.
      3. Parse pnp as specified by the org.bluetooth.characteristic.pnp_id characteristic definition. If it's not 7 bytes long or if the Vendor ID Source is not 1 or 2, abort these substeps.
      4. Set result.vendorIDSource according to the following table:

         Parsed Vendor Id Source	vendorIDSource
         1	"bluetooth"
         2	"usb"

      5. Set result.vendorID to the value parsed for Vendor ID.
      6. Set result.productID to the value parsed for Product ID.
      7. Set result.productVersion to the value parsed for Product Version.
   10. Initialize result.paired to the value of device's bonded flag.
   11. Let uuids be an empty set of UUIDs.
   12. Add device's advertised Service UUIDs to uuids.
   13. The UA MAY populate the Bluetooth cache with all Services inside device. Ignore any errors from this step.
   14. If the Bluetooth cache contains known-present Services inside device, add the UUIDs of those Services to uuids.
   15. Initialize result.uuids to a read only Array holding the elements of uuids that are also in result@[[\allowedServices]].
   16. Resolve promise with result.

The connectGATT() method, when invoked, MUST return a new promise promise and run the following steps in parallel:

1. If this@[[\representedDevice]] has no ATT Bearer, attempt to create one using the procedures described in "Connection Establishment" under GAP Interoperability Requirements.
2. If this attempt fails, reject promise with a NetworkError and abort these steps.
3. Queue a task to do the following steps:
   1. If this.gattServer is null, set it to a new BluetoothGATTRemoteServer instance with its device attribute initialized to this and its connected attribute initialized to true.
   2. Resolve promise with this.gattServer.

            interface BluetoothAdvertisingData {
              readonly attribute unsigned short? appearance;
              readonly attribute byte? txPower;
              readonly attribute byte? rssi;
              readonly attribute Map manufacturerData;
              readonly attribute Map serviceData;
            };
          

GATT Information Model

BluetoothGATTRemoteServer

BluetoothGATTRemoteServer represents a GATT Server on a remote device.

          interface BluetoothGATTRemoteServer {
            readonly attribute BluetoothDevice device;
            readonly attribute boolean connected;
            void disconnect();
            Promise<BluetoothGATTService> getPrimaryService(BluetoothServiceUUID service);
            Promise<sequence<BluetoothGATTService>>
              getPrimaryServices(optional BluetoothServiceUUID service);
          };
          BluetoothGATTRemoteServer implements EventTarget;
          BluetoothGATTRemoteServer implements CharacteristicEventHandlers;
          BluetoothGATTRemoteServer implements ServiceEventHandlers;
        

The disconnect() method, when invoked, MUST perform the following steps:

1. Set this.connected to false.
2. In parallel: if, for all script execution environments, all BluetoothDevices device with device@[[\representedDevice]] the same device as this.device@[[\representedDevice]], device.gattServer === null or !device.gattServer.connected, the UA MAY destroy device@[[\representedDevice]]'s ATT Bearer.

The getPrimaryService(service) method, when invoked, MUST return

GetGATTChildren(attribute=this@[[\representedDevice]],
single=true,
uuidCanonicalizer=BluetoothUUID.getService,
uuid=service,
child type="GATT Primary Service")

The getPrimaryServices(service) method, when invoked, MUST return

GetGATTChildren(attribute=this@[[\representedDevice]],
single=false,
uuidCanonicalizer=BluetoothUUID.getService,
uuid=service,
child type="GATT Primary Service")

BluetoothGATTService

BluetoothGATTService represents a GATT Service, a collection of characteristics and relationships to other services that encapsulate the behavior of part of a device.

          interface BluetoothGATTService {
            readonly attribute BluetoothDevice device;
            readonly attribute UUID uuid;
            readonly attribute boolean isPrimary;
            Promise<BluetoothGATTCharacteristic>
              getCharacteristic(BluetoothCharacteristicUUID characteristic);
            Promise<sequence<BluetoothGATTCharacteristic>>
              getCharacteristics(optional BluetoothCharacteristicUUID characteristic);
            Promise<BluetoothGATTService>
              getIncludedService(BluetoothServiceUUID service);
            Promise<sequence<BluetoothGATTService>>
              getIncludedServices(optional BluetoothServiceUUID service);
          };
          BluetoothGATTService implements EventTarget;
          BluetoothGATTService implements CharacteristicEventHandlers;
          BluetoothGATTService implements ServiceEventHandlers;
        

To create a BluetoothGATTService representing a Service service, the UA must return a new promise promise and run the following steps in parallel.

1. Let result be a new instance of BluetoothGATTService.
2. Get the BluetoothDevice representing the device in which service appears, and let devicePromise be the result.
3. Wait for devicePromise to settle.
4. If devicePromise rejected, resolve promise with devicePromise and abort these steps.
5. Initialize result.device from the value of devicePromise.
6. Initialize result.uuid from the UUID of service.
7. If service is a Primary Service, initialize result.isPrimary to true. Otherwise initialize result.isPrimary to false.
8. Resolve promise with result.

The getCharacteristic(characteristic) method retrieves a Characteristic inside this Service. When invoked, it MUST return

GetGATTChildren(attribute=this,
single=true,
uuidCanonicalizer=BluetoothUUID.getCharacteristic,
uuid=characteristic,
child type="GATT Characteristic")

The getCharacteristics(characteristic) method retrieves a list of Characteristics inside this Service. When invoked, it MUST return

GetGATTChildren(attribute=this,
single=false,
uuidCanonicalizer=BluetoothUUID.getCharacteristic,
uuid=characteristic,
child type="GATT Characteristic")

The getIncludedService(service) method retrieves an Included Service inside this Service. When invoked, it MUST return

GetGATTChildren(attribute=this,
single=true,
uuidCanonicalizer=BluetoothUUID.getService,
uuid=service,
child type="GATT Included Service")

The getIncludedServices(service) method retrieves a list of Included Services inside this Service. When invoked, it MUST return

GetGATTChildren(attribute=this,
single=false,
uuidCanonicalizer=BluetoothUUID.getService,
uuid=service,
child type="GATT Included Service")

BluetoothGATTCharacteristic

BluetoothGATTCharacteristic represents a GATT Characteristic, which is a basic data element that provides further information about a peripheral's service.

          interface BluetoothGATTCharacteristic {
            readonly attribute BluetoothGATTService service;
            readonly attribute UUID uuid;
            readonly attribute CharacteristicProperties properties;
            readonly attribute ArrayBuffer? value;
            Promise<BluetoothGATTDescriptor> getDescriptor(BluetoothDescriptorUUID descriptor);
            Promise<sequence<BluetoothGATTDescriptor>>
              getDescriptors(optional BluetoothDescriptorUUID descriptor);
            Promise<ArrayBuffer> readValue();
            Promise<void> writeValue(BufferSource value);
            Promise<void> startNotifications();
            Promise<void> stopNotifications();
          };
          BluetoothGATTCharacteristic implements EventTarget;
          BluetoothGATTCharacteristic implements CharacteristicEventHandlers;
        

To create a BluetoothGATTCharacteristic representing a Characteristic characteristic, the UA must return a new promise promise and run the following steps in parallel.

1. Let result be a new instance of BluetoothGATTCharacteristic.
2. Initialize result.service from the BluetoothGATTService instance representing the Service in which characteristic appears.
3. Initialize result.uuid from the UUID of characteristic.
4. Create a CharacteristicProperties instance from the Characteristic characteristic, and let propertiesPromise be the result.
5. Wait for propertiesPromise to settle.
6. If propertiesPromise was rejected, resolve promise with propertiesPromise and abort these steps.
7. Initialize result.properties from the value propertiesPromise was fulfilled with.
8. Initialize result.value to null. The UA MAY initialize result.value to a new ArrayBuffer containing the most recently read value from characteristic if this value is available.
9. Resolve promise with result.

The getDescriptor(descriptor) method retrieves a Descriptor inside this Characteristic. When invoked, it MUST return

GetGATTChildren(attribute=this,
single=true,
uuidCanonicalizer=BluetoothUUID.getDescriptor,
uuid=descriptor,
child type="GATT Descriptor")

The getDescriptors(descriptor) method retrieves a list of Descriptors inside this Characteristic. When invoked, it MUST return

GetGATTChildren(attribute=this,
single=false,
uuidCanonicalizer=BluetoothUUID.getDescriptor,
uuid=descriptor,
child type="GATT Descriptor")

The readValue() method, when invoked, MUST return a new promise promise and run the following steps in parallel:

1. If this.uuid is blacklisted for reads, return a promise rejected with a SecurityError and abort these steps.
2. Let characteristic be the Characteristic that this represents.
3. If the Read bit is not set in characteristic's properties, reject promise with a NotSupportedError and abort these steps.
4. Use any combination of the sub-procedures in the Characteristic Value Read procedure to retrieve the value of characteristic. Handle errors as described in .
5. If the previous step returned an error, reject promise with that error and abort these steps.
6. Queue a task to perform the following steps:
   1. Create an ArrayBuffer holding the retrieved value, and assign it to this.value.
   2. Resolve promise with this.value.
   3. Fire an event named characteristicvaluechanged with its bubbles attribute initialized to true at this.

The writeValue(value) method, when invoked, MUST run the following steps:

1. If this.uuid is blacklisted for writes, return a promise rejected with a SecurityError and abort these steps.
2. Let characteristic be the Characteristic that this represents.
3. Let bytes be a copy of the bytes held by value.
4. If bytes is more than 512 bytes long (the maximum length of an attribute value, per Long Attribute Values) return a promise rejected with an InvalidModificationError and abort these steps.
5. Return a new promise promise and run the following steps in parallel.
   1. Use any combination of the sub-procedures in the Characteristic Value Write procedure to write bytes to characteristic. Handle errors as described in .
   2. If the previous step returned an error, reject promise with that error and abort these steps.
   3. Queue a task to perform the following steps:
      1. Set this.value to a new ArrayBuffer containing bytes.
      2. Resolve promise with undefined.

For each known GATT Characteristic, the UA MUST maintain an active notification context set of Bluetooth objects. This is a single set for the whole UA, pointing to the navigator.bluetooth object for each separate script execution environment that has registered for notifications.

The startNotifications() method, when invoked, MUST return a new promise promise and run the following steps in parallel. See for details of receiving notifications.

1. If this.uuid is blacklisted for reads, reject promise with a SecurityError and abort these steps.
2. Let characteristic be the GATT Characteristic that this represents.
3. If neither of the Notify or Indicate bits are set in characteristic's properties, reject promise with a NotSupportedError and abort these steps.
4. If the active notification context set contains navigator.bluetooth, resolve promise with undefined and abort these steps.
5. Use any of the Characteristic Descriptors procedures to ensure that one of the Notification or Indication bits in characteristic's Client Characteristic Configuration descriptor is set, matching the constraints in characteristic's properties. The UA SHOULD avoid setting both bits, and MUST deduplicate value-change events if both bits are set. Handle errors as described in .
6. If the previous step returned an error, reject promise with that error and abort these steps.
7. Add navigator.bluetooth to the active notification context set.
8. Resolve promise with undefined.

After notifications are enabled, the resulting value-change events won't be delivered until after the current microtask checkpoint. This allows a developer to set up handlers in the .then handler of the result promise.

The stopNotifications() method, when invoked, MUST return a new promise promise and run the following steps in parallel:

1. Let characteristic be the GATT Characteristic that this represents.
2. If the active notification context set contains navigator.bluetooth, remove it.
3. If the active notification context set became empty, the UA SHOULD use any of the Characteristic Descriptors procedures to clear the Notification and Indication bits in characteristic's Client Characteristic Configuration descriptor.
4. Queue a task to resolve promise with undefined.

Queuing a task to resolve the promise ensures that no value change events due to notifications arrive after the promise resolves.

            interface BluetoothCharacteristicProperties {
              readonly attribute boolean broadcast;
              readonly attribute boolean read;
              readonly attribute boolean writeWithoutResponse;
              readonly attribute boolean write;
              readonly attribute boolean notify;
              readonly attribute boolean indicate;
              readonly attribute boolean authenticatedSignedWrites;
              readonly attribute boolean reliableWrite;
              readonly attribute boolean writableAuxiliaries;
            };
          

BluetoothGATTDescriptor

BluetoothGATTDescriptor represents a GATT Descriptor, which provides further information about a Characteristic's value.

          interface BluetoothGATTDescriptor {
            readonly attribute BluetoothGATTCharacteristic characteristic;
            readonly attribute UUID uuid;
            readonly attribute ArrayBuffer? value;
            Promise<ArrayBuffer> readValue();
            Promise<void> writeValue(BufferSource value);
          };
        

To create a BluetoothGATTDescriptor representing a Descriptor descriptor, the UA must return a new promise promise and run the following steps in parallel.

1. Let result be a new instance of BluetoothGATTDescriptor.
2. Initialize result.characteristic from the BluetoothGATTCharacteristic instance representing the Characteristic in which descriptor appears.
3. Initialize result.uuid from the UUID of descriptor.
4. Initialize result.value to null. The UA MAY initialize result.value to a new ArrayBuffer containing the most recently read value from descriptor if this value is available.
5. Resolve promise with result.

The readValue() method, when invoked, MUST return a new promise promise and run the following steps in parallel:

1. If this.uuid is blacklisted for reads, return a promise rejected with a SecurityError and abort these steps.
2. Let descriptor be the Descriptor that this represents.
3. Use either the Read Characteristic Descriptors or the Read Long Characteristic Descriptors sub-procedure to retrieve the value of descriptor. Handle errors as described in .
4. If the previous step returned an error, reject promise with that error and abort these steps.
5. Queue a task to perform the following steps:
   1. Create an ArrayBuffer holding the retrieved value, and assign it to this.value.
   2. Resolve promise with this.value.

The writeValue(value) method, when invoked, MUST run the following steps:

1. If this.uuid is blacklisted for writes, return a promise rejected with a SecurityError and abort these steps.
2. Let descriptor be the Descriptor that this represents.
3. Let bytes be a copy of the bytes held by value.
4. If bytes is more than 512 bytes long (the maximum length of an attribute value, per Long Attribute Values) return a promise rejected with an InvalidModificationError and abort these steps.
5. Return a new promise promise and run the following steps in parallel.
   1. Use either the Write Characteristic Descriptors or the Write Long Characteristic Descriptors sub-procedure to write bytes to descriptor. Handle errors as described in .
   2. If the previous step returned an error, reject promise with that error and abort these steps.
   3. Queue a task to perform the following steps:
      1. Set this.value to a new ArrayBuffer containing bytes.
      2. Resolve promise with undefined.

Events

            [NoInterfaceObject]
            interface CharacteristicEventHandlers {
              attribute EventHandler oncharacteristicvaluechanged;
            };
          

            [NoInterfaceObject]
            interface ServiceEventHandlers {
              attribute EventHandler onserviceadded;
              attribute EventHandler onservicechanged;
              attribute EventHandler onserviceremoved;
            };
          

Error handling

This section primarily defines the mapping from system errors to Javascript error names and allows UAs to retry certain operations. The retry logic and possible error distinctions are highly constrained by the operating system, so places these requirements don't reflect reality are likely spec bugs instead of browser bugs.

When the UA is using a GATT procedure to execute a step in an algorithm or to handle a query to the Bluetooth cache (both referred to as a "step", here), and the GATT procedure returns an Error Response, the UA MUST perform the following steps:

1. If the procedure times out or the ATT Bearer (described in Profile Fundamentals) is terminated for any reason, return a NetworkError from the step and abort these steps.
2. Take the following actions depending on the Error Code:

   Invalid PDU

   Invalid Offset

   Attribute Not Found

   Unsupported Group Type

   These error codes indicate that something unexpected happened at the protocol layer, likely either due to a UA or device bug. Return a NotSupportedError from the step.

   Invalid Handle

   This can happen if an attribute is removed from the GATT server during another procedure. Usually applications can avoid this error by listening for the servicechanged and serviceremoved events, but there's necessarily a gap between the Bluetooth message reporting a change and the Javascript event communicating it to a web page, in which the web page can start an invalid operation.

   Return an InvalidStateError from the step.

   Invalid Attribute Value Length

   Return an InvalidModificationError from the step.

   Attribute Not Long

   If this error code is received without having used a "Long" sub-procedure, this may indicate a device bug. Return a NotSupportedError from the step.

   Otherwise, retry the step without using a "Long" sub-procedure. If this is impossible due to the length of the value being written, return an InvalidModificationError from the step.

   Insufficient Authentication

   Insufficient Encryption

   Insufficient Encryption Key Size

   The UA SHOULD attempt to increase the security level of the connection. If this attempt fails or the UA doesn't support any higher security, Return a SecurityError from the step. Otherwise, retry the step at the new higher security level.

   Insufficient Authorization

   Return a SecurityError from the step.

   Application Error

   If the GATT procedure was a Write, return an InvalidModificationError from the step. Otherwise, return a NotSupportedError from the step.

   Read Not Permitted

   Write Not Permitted

   Request Not Supported

   Prepare Queue Full

   Insufficient Resources

   Unlikely Error

   Anything else

   Return a NotSupportedError from the step.

Standardized UUIDs

The Bluetooth SIG maintains a registry at [[BLUETOOTH-ASSIGNED]] of UUIDs that identify services, characteristics, descriptors, and other entities. This section provides a way for script to look up those UUIDs by name so they don't need to be replicated in each application.

          interface BluetoothUUID {
            static UUID getService((DOMString or unsigned long) name);
            static UUID getCharacteristic((DOMString or unsigned long) name);
            static UUID getDescriptor((DOMString or unsigned long) name);

            static UUID canonicalUUID([EnforceRange] unsigned long alias);
          };

          typedef (DOMString or unsigned long) BluetoothServiceUUID;
          typedef (DOMString or unsigned long) BluetoothCharacteristicUUID;
          typedef (DOMString or unsigned long) BluetoothDescriptorUUID;
        

The static BluetoothUUID.canonicalUUID(alias) method, when invoked, MUST return the 128-bit UUID represented by the 16- or 32-bit UUID alias alias.

This algorithm consists of replacing the top 32 bits of "00000000-0000-1000-8000-00805f9b34fb" with the bits of the alias. For example, canonicalUUID(0xDEADBEEF) returns "deadbeef-0000-1000-8000-00805f9b34fb".

BluetoothServiceUUID represents 16- and 32-bit UUID aliases, valid UUIDs, and names defined in [[BLUETOOTH-ASSIGNED-SERVICES]], or, equivalently, the values for which BluetoothUUID.getService does not throw an exception.

The static BluetoothUUID.getService(name) method, when invoked, MUST run the following steps:

1. If name is an unsigned long, return BluetoothUUID.canonicalUUID(name) and abort these steps.
2. If name is a valid UUID, return name and abort these steps.
3. If org.bluetooth.service.name appears in [[!BLUETOOTH-ASSIGNED-SERVICES]], let alias be its assigned number, and return BluetoothUUID.canonicalUUID(alias).
4. Otherwise, throw a SyntaxError.

BluetoothCharacteristicUUID represents 16- and 32-bit UUID aliases, valid UUIDs, and names defined in [[BLUETOOTH-ASSIGNED-CHARACTERISTICS]], or, equivalently, the values for which BluetoothUUID.getCharacteristic does not throw an exception.

The static BluetoothUUID.getCharacteristic(name) method, when invoked, MUST run the following steps:

1. If name is an unsigned long, return BluetoothUUID.canonicalUUID(name) and abort these steps.
2. If name is a valid UUID, return name and abort these steps.
3. If org.bluetooth.characteristic.name appears in [[!BLUETOOTH-ASSIGNED-CHARACTERISTICS]], let alias be its assigned number, and return BluetoothUUID.canonicalUUID(alias).
4. Otherwise, throw a SyntaxError.

BluetoothDescriptorUUID represents 16- and 32-bit UUID aliases, valid UUIDs, and names defined in [[BLUETOOTH-ASSIGNED-DESCRIPTORS]], or, equivalently, the values for which BluetoothUUID.getDescriptor does not throw an exception.

The static BluetoothUUID.getDescriptor(name) method, when invoked, MUST run the following steps:

1. If name is an unsigned long, return BluetoothUUID.canonicalUUID(name) and abort these steps.
2. If name is a valid UUID, return name and abort these steps.
3. If org.bluetooth.descriptor.name appears in [[!BLUETOOTH-ASSIGNED-DESCRIPTORS]], let alias be its assigned number, and return BluetoothUUID.canonicalUUID(alias).
4. Otherwise, throw a SyntaxError.