Title: Web Bluetooth
Repository: WebBluetoothCG/web-bluetooth
Status: CG-DRAFT
ED: https://webbluetoothcg.github.io/web-bluetooth/
Shortname: web-bluetooth
Level: 1
Translation: ja https://tkybpp.github.io/web-bluetooth-jp/
Editor: Reilly Grant 83788, Google LLC https://www.google.com, reillyg@google.com
Editor: Ovidio Ruiz-Henríquez 106543, Google LLC https://www.google.com, odejesush@google.com
Editor: See contributors on GitHub, , https://github.com/WebBluetoothCG/web-bluetooth/graphs/contributors
Abstract: This document describes an API to discover and communicate with devices
Abstract: over the Bluetooth 4 wireless standard using the Generic Attribute Profile (GATT).

Group: web-bluetooth-cg
!Participate: Join the W3C Community Group
!Participate: Fix the text through GitHub
!Participate: public-web-bluetooth@w3.org (archives)
!Participate: IRC: #web-bluetooth on W3C's IRC

Markup Shorthands: css no, markdown yes

{
  "BLUETOOTH42": {
    "href": "https://www.bluetooth.org/DocMan/handlers/DownloadDoc.ashx?doc_id=286439",
    "title": "BLUETOOTH SPECIFICATION Version 4.2",
    "publisher": "Bluetooth SIG",
    "date": "2 December 2014"
  },
  "BLUETOOTH-ASSIGNED": {
    "href": "https://www.bluetooth.com/specifications/assigned-numbers/",
    "title": "Assigned Numbers",
    "status": "Living Standard",
    "publisher": "Bluetooth SIG"
  },
  "BLUETOOTH-SUPPLEMENT6": {
    "href": "https://www.bluetooth.org/DocMan/handlers/DownloadDoc.ashx?doc_id=302735",
    "title": "Supplement to the Bluetooth Core Specification Version 6",
    "date": "14 July 2015",
    "publisher": "Bluetooth SIG"
  }
}

spec: assigned-numbers
    type: enum; urlPrefix: https://github.com/WebBluetoothCG/registries/
        urlPrefix: blob/master/gatt_assigned_characteristics.txt
            text: body_sensor_location; url: #:~:text=body_sensor_location
            text: gap.appearance; url: #:~:text=gap.appearance
            text: heart_rate_control_point; url: #:~:text=heart_rate_control_point
            text: heart_rate_measurement; url: #:~:text=heart_rate_measurement
            text: ieee_11073-20601_regulatory_certification_data_list; url: #:~:text=ieee_11073-20601_regulatory_certification_data_list
        urlPrefix: blob/master/gatt_assigned_descriptors.txt
            text: gatt.characteristic_presentation_format; url: #:~:text=gatt.characteristic_presentation_format
            text: gatt.client_characteristic_configuration; url: #:~:text=gatt.client_characteristic_configuration
        urlPrefix: blob/master/gatt_assigned_services.txt
            text: cycling_power; url: #:~:text=cycling_power
            text: heart_rate; url: #:~:text=heart_rate

spec: BLUETOOTH-ASSIGNED
    type: dfn
        text: Shortened Local Name; url: https://www.bluetooth.com/specifications/assigned-numbers/#:~:text=Generic%20Access%20Profile

spec: ECMAScript; urlPrefix: https://tc39.github.io/ecma262/#
    type: dfn
        text: current realm; url: current-realm
        text: fulfilled; url: sec-promise-objects
        text: internal slot; url: sec-object-internal-methods-and-internal-slots
        text: realm; url: sec-code-realms
    type: method
        text: Array.prototype.map; url: sec-array.prototype.map
    type: interface
        text: Array; url: sec-array-objects
        text: ArrayBuffer; url: sec-arraybuffer-constructor
        text: DataView; url: sec-dataview-constructor
        text: Map; url: sec-map-constructor
        text: Promise; url:sec-promise-objects
        text: Set; url: sec-set-objects
        text: TypeError; url: sec-native-error-types-used-in-this-standard-typeerror
        text: TypedArray; url: sec-typedarray-constructors

spec: fingerprinting-guidance; urlPrefix: https://w3c.github.io/fingerprinting-guidance/#
    type: dfn
        text: fingerprinting surface; url: dfn-fingerprinting-surface

spec: html; urlPrefix: https://html.spec.whatwg.org/multipage/browsing-the-web.html#
    type: dfn
        text: initializing the Document object; url: initialise-the-document-object

spec: html; urlPrefix: https://html.spec.whatwg.org/multipage/document-sequences.html#
    type: dfn
        text: navigable; url: navigable

spec: WebIDL; urlPrefix: https://heycam.github.io/webidl/#
    type: dfn
        text: a copy of the bytes held; url: dfn-get-buffer-source-copy

spec: html; urlPrefix: https://html.spec.whatwg.org/multipage/browsing-the-web.html/#
    type: dfn
        text: initializing a new Document object; url: dfn-initialise-the-document-object

spec: PAGE-VISIBILITY; urlPrefix: https://www.w3.org/TR/page-visibility-2/#
    type: dfn
        text: document visibility state; url: dom-visibilitystate

spec: WEBDRIVER; urlPrefix: https://w3c.github.io/webdriver/
    type: dfn
        text: local end; url: dfn-local-ends
        text: invalid element state; url: dfn-invalid-element-state

spec:dom
    type:dfn
        text:children
        for:/
            text:document
spec: fingerprinting-guidance
    type: dfn
        text: fingerprinting surface
spec: html
    type: dfn
        text: allowed to use; for :/
        text: associated navigator; for: /
        text: browsing context; for: /
        text: global object; for: /
        text: navigable; for: /
spec: webidl
    type: dfn
        text: resolve
spec: webdriver
    type: dfn
        text: remote end steps
    type: dfn
        text: current browsing context
spec: webdriver2
    type: dfn
        text: success
        text: error

  let chosenHeartRateService = null;

  navigator.bluetooth.requestDevice({
    filters: [{
      services: ['heart_rate'],
    }]
  }).then(device => device.gatt.connect())
  .then(server => server.getPrimaryService('heart_rate'))
  .then(service => {
    chosenHeartRateService = service;
    return Promise.all([
      service.getCharacteristic('body_sensor_location')
        .then(handleBodySensorLocationCharacteristic),
      service.getCharacteristic('heart_rate_measurement')
        .then(handleHeartRateMeasurementCharacteristic),
    ]);
  });

  function handleBodySensorLocationCharacteristic(characteristic) {
    if (characteristic === null) {
      console.log("Unknown sensor location.");
      return Promise.resolve();
    }
    return characteristic.readValue()
    .then(sensorLocationData => {
      const sensorLocation = sensorLocationData.getUint8(0);
      switch (sensorLocation) {
        case 0: return 'Other';
        case 1: return 'Chest';
        case 2: return 'Wrist';
        case 3: return 'Finger';
        case 4: return 'Hand';
        case 5: return 'Ear Lobe';
        case 6: return 'Foot';
        default: return 'Unknown';
      }
    }).then(location => console.log(location));
  }

  function handleHeartRateMeasurementCharacteristic(characteristic) {
    return characteristic.startNotifications()
    .then(char => {
      characteristic.addEventListener('characteristicvaluechanged',
                                      onHeartRateChanged);
    });
  }

  function onHeartRateChanged(event) {
    const characteristic = event.target;
    console.log(parseHeartRate(characteristic.value));
  }

  function parseHeartRate(data) {
    const flags = data.getUint8(0);
    const rate16Bits = flags & 0x1;
    const result = {};
    let index = 1;
    if (rate16Bits) {
      result.heartRate = data.getUint16(index, /*littleEndian=*/true);
      index += 2;
    } else {
      result.heartRate = data.getUint8(index);
      index += 1;
    }
    const contactDetected = flags & 0x2;
    const contactSensorPresent = flags & 0x4;
    if (contactSensorPresent) {
      result.contactDetected = !!contactDetected;
    }
    const energyPresent = flags & 0x8;
    if (energyPresent) {
      result.energyExpended = data.getUint16(index, /*littleEndian=*/true);
      index += 2;
    }
    const rrIntervalPresent = flags & 0x10;
    if (rrIntervalPresent) {
      const rrIntervals = [];
      for (; index + 1 < data.byteLength; index += 2) {
        rrIntervals.push(data.getUint16(index, /*littleEndian=*/true));
      }
      result.rrIntervals = rrIntervals;
    }
    return result;
  }

  {
    heartRate: 70,
    contactDetected: true,
    energyExpended: 750,     // Meaning 750kJ.
    rrIntervals: [890, 870]  // Meaning .87s and .85s.
  }

  function resetEnergyExpended() {
    if (!chosenHeartRateService) {
      return Promise.reject(new Error('No heart rate sensor selected yet.'));
    }
    return chosenHeartRateService.getCharacteristic('heart_rate_control_point')
    .then(controlPoint => {
      const resetEnergyExpended = new Uint8Array([1]);
      return controlPoint.writeValue(resetEnergyExpended);
    });
  }

  navigator.bluetooth.requestDevice({
    filters: [ {services: [A, B]} ]
  });

  navigator.bluetooth.requestDevice({
    filters: [
      {services: [A, B]},
      {services: [C, D]}
    ]
  });

  navigator.bluetooth.getDevices();

  navigator.bluetooth.requestDevice({
    filters: [ {services: [A, B]} ],
    optionalServices: \[E]
  });

  navigator.bluetooth.getDevices();

        [{name: "Unique Name"}]
      

        [{namePrefix: "Device"}]
      

        [{name: "First De"},
          {name: "First Device"}]
      

        [{namePrefix: "First"},
          {name: "Unique Name"}]
      

        [{services: \[C],
          namePrefix: "Device"},
          {name: "Unique Name"}]
      

        [{namePrefix: "Device"}]  // D3, D4
      

        [{name: "Device Third"}]   // D3
      

        [{namePrefix: "Device"}]  // D3, D4
      

        [{namePrefix: "Device F"}] // D4
      

        [{services: \[C]},         // D1, D3
          {namePrefix: "Device"}] // D3, D4
      

        [{services: \[A]},          // D1
          {name: "Device Fourth"}] // D4
      

[{ manufacturerData: [{ companyIdentifier: 17 }] }]
      

[{ serviceData: [{ service: "A" }] }]
      

[
  { manufacturerData: [{ companyIdentifier: 17 }] },
  { serviceData: [{ service: "A" }] },
]
      

[
  {
    manufacturerData: [{ companyIdentifier: 17 }],
    serviceData: [{ service: "A" }],
  },
]
      

[
  {
    manufacturerData: [
      {
        companyIdentifier: 17,
        dataPrefix: new Uint8Array([1, 2, 3])
      },
    ],
  },
]
      

[
  {
    manufacturerData: [
      {
        companyIdentifier: 17,
        dataPrefix: new Uint8Array([1, 2, 3, 4])
      },
    ],
  },
]
      

[
  {
    manufacturerData: [
      {
        companyIdentifier: 17,
        dataPrefix: new Uint8Array([1])
      },
    ],
  },
]
      

[
  {
    manufacturerData: [
      {
        companyIdentifier: 17,
        dataPrefix: new Uint8Array([0x91, 0xAA]),
        mask: new Uint8Array([0x0f, 0x57]),
      },
    ],
  },
]
      

[
  {
    manufacturerData: [
      { companyIdentifier: 17 },
      { companyIdentifier: 18 },
    ]
  }
]
      

        requestDevice({})
      

        requestDevice({filters:[]})
      

        requestDevice({filters:[{}]})
      

        requestDevice({
          acceptAllDevices:true
        })
      

        requestDevice({
          filters: [...],
          acceptAllDevices:true
        })
      

        requestDevice({
          exclusionFilters: [...],
          acceptAllDevices:true
        })
      

        requestDevice({
          exclusionFilters: [...]
        })
      

        requestDevice({
          filters: [...],
          exclusionFilters: []
        })
      

        requestDevice({
          filters: [{namePrefix: ""}]
        })
      

        requestDevice({
          filters: [{manufacturerData: []}]
        })
      

        requestDevice({
          filters: [{serviceData: []}]
        })
      

    {
      name: "bluetooth",
      filters: uuidFilters
      optionalServices: optionalServiceUUIDs,
      optionalManufacturerData: optionalManufacturerData
      acceptAllDevices: filters !== null,
    }
    

  navigator.permissions.query({
    name: "bluetooth",
    deviceId: sessionStorage.lastDevice,
  }).then(result => {
    if (result.devices.length == 1) {
      return result.devices[0];
    } else {
      throw new DOMException("Lost permission", "NotFoundError");
    }
  }).then(...);

const bluetoothUI = document.querySelector('#bluetoothUI');
navigator.bluetooth.getAvailability().then(isAvailable => {
  bluetoothUI.hidden = !isAvailable;
});
navigator.bluetooth.addEventListener('availabilitychanged', e => {
  bluetoothUI.hidden = !e.value;
});

function checkAvailability() {
  const bluetoothUI = document.querySelector('#bluetoothUI');
  navigator.bluetooth.getAvailability().then(isAvailable => {
    bluetoothUI.hidden = !isAvailable;
  });
}

navigator.permissions.query({name: "bluetooth"}).then(status => {
  if (status.state !== 'denied') checkAvailability();

  // Bluetooth is blocked, listen for change in PermissionStatus.
  status.onchange = () => {
    if (this.state !== 'denied') checkAvailability();
  };
});

  [
    Exposed=Window,
    SecureContext
  ]
  interface ValueEvent : Event {
    constructor(DOMString type, optional ValueEventInit initDict = {});
    readonly attribute any value;
  };

  dictionary ValueEventInit : EventInit {
    any value = null;
  };

  var known_service = "A service in the iBeacon's GATT server";
  return navigator.bluetooth.requestDevice({
    filters: [{services: [known_service]}]
  }).then(device => {
    device.watchAdvertisements();
    device.addEventListener('advertisementreceived', interpretIBeacon);
  });

  function interpretIBeacon(event) {
    var rssi = event.rssi;
    var appleData = event.manufacturerData.get(0x004C);
    if (appleData.byteLength != 23 ||
      appleData.getUint16(0, false) !== 0x0215) {
      console.log({isBeacon: false});
    }
    var uuidArray = new Uint8Array(appleData.buffer, 2, 16);
    var major = appleData.getUint16(18, false);
    var minor = appleData.getUint16(20, false);
    var txPowerAt1m = -appleData.getInt8(22);
    console.log({
        isBeacon: true,
        uuidArray,
        major,
        minor,
        pathLossVs1m: txPowerAt1m - rssi});
  });

      {
        bubbles: true,
        device: deviceObj,
        uuids: [],
        manufacturerData: new Map(),
        serviceData: new Map()
      }
    

advertisementreceived

Fired on a {{BluetoothDevice}} when an advertising event is received from that device.

availabilitychanged

Fired on {{Bluetooth|navigator.bluetooth}} when the Bluetooth system as a whole becomes available or unavailable to the UA.

characteristicvaluechanged

Fired on a {{BluetoothRemoteGATTCharacteristic}} when its value changes, either as a result of a read request , or a value change notification/indication.

gattserverdisconnected

Fired on a {{BluetoothDevice}} when an active GATT connection is lost.

serviceadded

Fired on a new {{BluetoothRemoteGATTService}} when it has been discovered on a remote device, just after it is added to the Bluetooth tree.

servicechanged

Fired on a {{BluetoothRemoteGATTService}} when its state changes. This involves any characteristics and/or descriptors that get added or removed from the service, as well as Service Changed indications from the remote device.

serviceremoved

Fired on a {{BluetoothRemoteGATTService}} when it has been removed from its device, just before it is removed from the Bluetooth tree.

bluetooth.BluetoothUuid = text;
bluetooth.BluetoothManufacturerData = { key: uint, data: tstr };
bluetooth.CharacteristicProperties = {
  ? broadcast: bool,
  ? read: bool,
  ? writeWithoutResponse: bool,
  ? write: bool,
  ? notify: bool,
  ? indicate: bool,
  ? authenticatedSignedWrites: bool,
  ? extendedProperties: bool
}

{^bluetooth.BluetoothManufacturerData/key^}

is the Company Identifier Code.

{^bluetooth.BluetoothManufacturerData/data^}

is the manufacturer data [=byte sequence=], base64 encoded.

bluetooth.RequestDevice = text

bluetooth.RequestDeviceInfo = {
   id: bluetooth.RequestDevice,
   name: text / null,
}

bluetooth.RequestDevicePrompt = text

bluetooth.ScanRecord = {
  ? name: text,
  ? uuids: [ * bluetooth.BluetoothUuid ],
  ? appearance: number,
  ? manufacturerData: [ * bluetooth.BluetoothManufacturerData ],
}

{^bluetooth.ScanRecord/name^}

is the [=Bluetooth device=]'s local name, or a prefix of it.

{^bluetooth.ScanRecord/uuids^}

lists the Service UUIDs that this scan record says the [=Bluetooth device=]'s GATT server supports.

{^bluetooth.ScanRecord/appearance^}

is an Appearance, one of the values defined by the {{gap.appearance}} characteristic.

{^bluetooth.ScanRecord/manufacturerData^}

list of BluetoothManufacturerData that maps {{unsigned short}} Company Identifier Codes to base64 encoded manufacturer data [=byte sequences=].

no such device

Tried to reference an unknown {{BluetoothDevice}}.

no such prompt

Tried to reference an unknown [=device prompt=].

BluetoothCommand = (
  bluetooth.HandleRequestDevicePrompt //
  bluetooth.SimulateAdapter //
  bluetooth.DisableSimulation //
  bluetooth.SimulatePreconnectedPeripheral //
  bluetooth.SimulateAdvertisement //
  bluetooth.SimulateGattConnectionResponse //
  bluetooth.SimulateGattDisconnection //
  bluetooth.SimulateService //
  bluetooth.SimulateCharacteristic //
  bluetooth.SimulateCharacteristicResponse //
  bluetooth.SimulateDescriptor //
  bluetooth.SimulateDescriptorResponse
)

bluetooth.HandleRequestDevicePrompt = (
   method: "bluetooth.handleRequestDevicePrompt",
   params: bluetooth.HandleRequestDevicePromptParameters,
)

bluetooth.HandleRequestDevicePromptParameters = {
   context: text,
   prompt: bluetooth.RequestDevicePrompt,
   (
       bluetooth.HandleRequestDevicePromptAcceptParameters //
       bluetooth.HandleRequestDevicePromptCancelParameters
   )
}

bluetooth.HandleRequestDevicePromptAcceptParameters = (
   accept: true,
   device: bluetooth.RequestDevice,
)

bluetooth.HandleRequestDevicePromptCancelParameters = (
   accept: false,
)

{
  "method": "bluetooth.handleRequestDevicePrompt",
  "params": {
    "context": "cxt-d03fdd81",
    "prompt": "pmt-e0a234b",
    "accept": true,
    "device": "dvc-9b3b872"
  }
}

bluetooth.SimulateAdapter = (
   method: "bluetooth.simulateAdapter",
   params: bluetooth.SimulateAdapterParameters,
)

bluetooth.SimulateAdapterParameters = {
   context: text,
   ? leSupported: bool,
   state: "absent" / "powered-off" / "powered-on"
}

{
  "method": "bluetooth.simulateAdapter",
  "params": {
    "context": "cxt-d03fdd81",
    "leSupported": true,
    "state": "powered-on",
  }
}

{
  "method": "bluetooth.simulateAdapter",
  "params": {
    "context": "cxt-d03fdd81",
    "state": "powered-off",
  }
}

bluetooth.DisableSimulation = (
   method: "bluetooth.disableSimulation",
   params: bluetooth.DisableSimulationParameters,
)

bluetooth.DisableSimulationParameters = {
   context: text
}

{
  "method": "bluetooth.disableSimulation",
  "params": {
    "context": "cxt-d03fdd81"
  }
}

bluetooth.SimulatePreconnectedPeripheral = (
   method: "bluetooth.simulatePreconnectedPeripheral",
   params: bluetooth.SimulatePreconnectedPeripheralParameters,
)

bluetooth.SimulatePreconnectedPeripheralParameters = {
   context: text,
   address: text,
   name: text,
   manufacturerData: [ * bluetooth.BluetoothManufacturerData ],
   knownServiceUuids: [ * bluetooth.BluetoothUuid ]
}

{
  "method": "bluetooth.simulatePreconnectedPeripheral",
  "params": {
    "context": "cxt-d03fdd81",
    "address": "09:09:09:09:09:09",
    "name": "Some Device",
    "manufacturerData": [ { key: 17, data: "AP8BAX8=" } ],
    "knownServiceUuids": [
      "12345678-1234-5678-9abc-def123456789",
    ],
  }
}

bluetooth.SimulateAdvertisement = (
   method: "bluetooth.simulateAdvertisement",
   params: bluetooth.SimulateAdvertisementParameters,
)

bluetooth.SimulateAdvertisementParameters = {
   context: text,
   scanEntry: bluetooth.SimulateAdvertisementScanEntryParameters
}

bluetooth.SimulateAdvertisementScanEntryParameters = {
   deviceAddress: text,
   rssi: number,
   scanRecord: bluetooth.ScanRecord
}

{
  "method": "bluetooth.simulateAdvertisement",
  "params": {
    "context": "cxt-d03fdd81",
    "scanEntry": {
      "deviceAddress": "08:08:08:08:08:08",
      "rssi": -10,
      "scanRecord": {
        "name": "Heart Rate",
        "uuids": ["0000180d-0000-1000-8000-00805f9b34fb"],
        "manufacturerData": [ { key: 17, data: "AP8BAX8=" } ],
        "appearance": 1,
        "txPower": 1
      }
    }
  }
}

bluetooth.SimulateGattConnectionResponse = (
   method: "bluetooth.simulateGattConnectionResponse",
   params: bluetooth.SimulateGattConnectionResponseParameters,
)

bluetooth.SimulateGattConnectionResponseParameters = {
   context: text,
   address: text,
   code: uint
}

{
  "method": "bluetooth.simulateGattConnectionResponse",
  "params": {
    "context": "cxt-d03fdd81",
    "address": "09:09:09:09:09:09",
    "code": 0
  }
}

bluetooth.SimulateGattDisconnection = (
   method: "bluetooth.simulateGattDisconnection",
   params: bluetooth.SimulateGattDisconnectionParameters,
)

bluetooth.SimulateGattDisconnectionParameters = {
   context: text,
   address: text,
}

{
  "method": "bluetooth.simulateGattDisconnection",
  "params": {
    "context": "cxt-d03fdd81",
    "address": "09:09:09:09:09:09",
  }
}

bluetooth.SimulateService = (
   method: "bluetooth.simulateService",
   params: bluetooth.SimulateServiceParameters,
)

bluetooth.SimulateServiceParameters = {
   context: text,
   address: text,
   uuid: bluetooth.BluetoothUuid,
   type: "add" / "remove",
}

{
  "method": "bluetooth.simulateService",
  "params": {
    "context": "cxt-d03fdd81",
    "address": "09:09:09:09:09:09",
    "uuid": "0000180d-0000-1000-8000-00805f9b34fb",
    "type": "add"
  }
}

{
  "method": "bluetooth.simulateService",
  "params": {
    "context": "cxt-d03fdd81",
    "address": "09:09:09:09:09:09",
    "uuid": "0000180d-0000-1000-8000-00805f9b34fb",
    "type": "remove"
  }
}

bluetooth.SimulateCharacteristic = (
   method: "bluetooth.simulateCharacteristic",
   params: bluetooth.SimulateCharacteristicParameters,
)

bluetooth.SimulateCharacteristicParameters = {
   context: text,
   address: text,
   serviceUuid: bluetooth.BluetoothUuid,
   characteristicUuid: bluetooth.BluetoothUuid,
   ? characteristicProperties: bluetooth.CharacteristicProperties,
   type: "add" / "remove"
}

{
  "method": "bluetooth.simulateCharacteristic",
  "params": {
    "context": "cxt-d03fdd81",
    "address": "09:09:09:09:09:09",
    "serviceUuid": "0000180d-0000-1000-8000-00805f9b34fb",
    "characteristicUuid": "00002a21-0000-1000-8000-00805f9b34fb",
    "characteristicProperties": {
      "read": true,
      "write": true,
      "notify": true
    },
    "type": "add"
  }
}

{
  "method": "bluetooth.simulateCharacteristic",
  "params": {
    "context": "cxt-d03fdd81",
    "address": "09:09:09:09:09:09",
    "serviceUuid": "0000180d-0000-1000-8000-00805f9b34fb",
    "characteristicUuid": "00002a21-0000-1000-8000-00805f9b34fb",
    "type": "remove"
  }
}

bluetooth.SimulateCharacteristicResponse = (
   method: "bluetooth.simulateCharacteristicResponse",
   params: bluetooth.SimulateCharacteristicResponseParameters,
)

bluetooth.SimulateCharacteristicResponseParameters = {
   context: text,
   address: text,
   serviceUuid: bluetooth.BluetoothUuid,
   characteristicUuid: bluetooth.BluetoothUuid,
   type: "read" / "write" / "subscribe-to-notifications" / "unsubscribe-from-notifications",
   code: uint,
   ? data: [ * uint ]
}

{
  "method": "bluetooth.simulateCharacteristicResponse",
  "params": {
    "context": "cxt-d03fdd81",
    "address": "09:09:09:09:09:09",
    "serviceUuid": "0000180d-0000-1000-8000-00805f9b34fb",
    "characteristicUuid": "00002a21-0000-1000-8000-00805f9b34fb",
    "type": "read",
    "code": 0,
    "data": [1, 2]
  }
}

bluetooth.SimulateDescriptor = (
   method: "bluetooth.simulateDescriptor",
   params: bluetooth.SimulateDescriptorParameters,
)

bluetooth.SimulateDescriptorParameters = {
   context: text,
   address: text,
   serviceUuid: bluetooth.BluetoothUuid,
   characteristicUuid: bluetooth.BluetoothUuid,
   descriptorUuid: bluetooth.BluetoothUuid,
   type: "add" / "remove"
}

{
  "method": "bluetooth.simulateDescriptor",
  "params": {
    "context": "cxt-d03fdd81",
    "address": "09:09:09:09:09:09",
    "serviceUuid": "0000180d-0000-1000-8000-00805f9b34fb",
    "characteristicUuid": "00002a21-0000-1000-8000-00805f9b34fb",
    "descriptorUuid": "00002901-0000-1000-8000-00805f9b34fb",
    "type": "add"
  }
}

{
  "method": "bluetooth.simulateDescriptor",
  "params": {
    "context": "cxt-d03fdd81",
    "address": "09:09:09:09:09:09",
    "serviceUuid": "0000180d-0000-1000-8000-00805f9b34fb",
    "characteristicUuid": "00002a21-0000-1000-8000-00805f9b34fb",
    "descriptorUuid": "00002901-0000-1000-8000-00805f9b34fb",
    "type": "remove"
  }
}

bluetooth.SimulateDescriptorResponse = (
   method: "bluetooth.simulateDescriptorResponse",
   params: bluetooth.SimulateDescriptorResponseParameters,
)

bluetooth.SimulateDescriptorResponseParameters = {
   context: text,
   address: text,
   serviceUuid: bluetooth.BluetoothUuid,
   characteristicUuid: bluetooth.BluetoothUuid,
   descriptorUuid: bluetooth.BluetoothUuid,
   type: "read" / "write",
   code: uint,
   ? data: [ * uint ]
}

{
  "method": "bluetooth.simulateDescriptorResponse",
  "params": {
    "context": "cxt-d03fdd81",
    "address": "09:09:09:09:09:09",
    "serviceUuid": "0000180d-0000-1000-8000-00805f9b34fb",
    "characteristicUuid": "00002a21-0000-1000-8000-00805f9b34fb",
    "descriptorUuid": "00002901-0000-1000-8000-00805f9b34fb",
    "type": "read",
    "code": 0,
    "data": [1, 2]
  }
}

BluetoothEvent = (
  bluetooth.RequestDevicePromptUpdated //
  bluetooth.GattConnectionAttempted
)

bluetooth.RequestDevicePromptUpdated = (
   method: "bluetooth.requestDevicePromptUpdated",
   params: bluetooth.RequestDevicePromptUpdatedParameters
)

bluetooth.RequestDevicePromptUpdatedParameters = {
   context: text,
   prompt: bluetooth.RequestDevicePrompt,
   devices: [* bluetooth.RequestDeviceInfo],
}

bluetooth.GattConnectionAttempted = (
   method: "bluetooth.gattConnectionAttempted",
   params: bluetooth.GattConnectionAttemptedParameters
)

bluetooth.GattConnectionAttemptedParameters = {
   context: text,
   address: text
}

bluetooth.CharacteristicEventGenerated = (
   method: "bluetooth.characteristicEventGenerated",
   params: bluetooth.CharacteristicEventGeneratedParameters
)

bluetooth.CharacteristicEventGeneratedParameters = {
  context: text,
  address: text,
  serviceUuid: bluetooth.BluetoothUuid,
  characteristicUuid: bluetooth.BluetoothUuid,
  type: "read" / "write-with-response" / "write-without-response" / "subscribe-to-notifications" / "unsubscribe-from-notifications",
  ? data: [ * uint ]
}

bluetooth.DescriptorEventGenerated = (
   method: "bluetooth.descriptorEventGenerated",
   params: bluetooth.DescriptorEventGeneratedParameters
)

bluetooth.DescriptorEventGeneratedParameters = {
  context: text,
  address: text,
  serviceUuid: bluetooth.BluetoothUuid,
  characteristicUuid: bluetooth.BluetoothUuid,
  descriptorUuid: bluetooth.BluetoothUuid,
  type: "read" / "write",
  ? data: [ * uint ]
}

[[!BLUETOOTH42]]

1. Architecture & Terminology Overview
   1. General Description
      2. Overview of Bluetooth Low Energy Operation (defines advertising events)
   4. Communication Topology and Operation
      2. Operational Procedures and Modes
         1. BR/EDR Procedures
            1. Inquiry (Discovering) Procedure
               1. Extended Inquiry Response
2. Core System Package [BR/EDR Controller volume]
   4. Error Codes
      1. Overview of Error Codes
         3. List of Error Codes
   5. Host Controller Interface Functional Specification
      7. HCI Commands and Events
         4. Informational Parameters
            6. Read BD_ADDR Command
         5. Status Parameters
            4. Read RSSI Command
3. Core System Package [Host volume]
   2. Service Discovery Protocol (SDP) Specification
      2. Overview
         5. Searching for Services
            1. UUID (defines UUID aliases and the algorithm to compute the 128-bit UUID represented by a UUID alias)
   3. Generic Access Profile
      2. Profile Overview
         2. Profile Roles
            2. Roles when Operating over an LE Physical Transport
               1. Broadcaster Role
               2. Observer Role
               3. Peripheral Role
               4. Central Role
      3. User Interface Aspects
         2. Representation of Bluetooth Parameters
            2. Bluetooth Device Name (the user-friendly name)
      6. Idle Mode Procedures — BR/EDR Physical Transport
         4. Device Discovery Procedure
         5. BR/EDR Bonding Procedure
      9. Operational Modes and Procedures — LE Physical Transport
         1. Broadcast Mode and Observation Procedure
            2. Observation Procedure
         2. Discovery Modes and Procedures
            6. General Discovery Procedure
            7. Name Discovery Procedure
         3. Connection Modes and Procedures
         4. Bonding Modes and Procedures
            4. LE Bonding Procedure
      10. Security Aspects — LE Physical Transport
          7. Privacy Feature
          8. Random Device Address
             1. Static Address
             2. Private address
                3. Resolvable Private Address Resolution Procedure
      11. Advertising Data and Scan Response Data Format (defines AD structure)
      15. Bluetooth Device Requirements
          1. Bluetooth Device Address (defines BD_ADDR)
             1. Bluetooth Device Address Types
                1. Public Bluetooth Address
      16. Definitions (defines bond)
   6. Attribute Protocol (ATT)
      3. Protocol Requirements
         2. Basic Concepts
            1. Attribute Type
            2. Attribute Handle
            9. Long Attribute Values
         4. Attribute Protocol Pdus
            1. Error Handling
               1. Error Response
   7. Generic Attribute Profile (GATT)
      2. Profile Overview
         2. Configurations and Roles (defines GATT Client and GATT Server)
         4. Profile Fundamentals, defines the ATT Bearer
         5. Attribute Protocol
            2. Attribute Caching
         6. GATT Profile Hierarchy
            2. Service
            3. Included Services
            4. Characteristic
      3. Service Interoperability Requirements
         1. Service Definition
         3. Characteristic Definition
            1. Characteristic Declaration
               1. Characteristic Properties
            3. Characteristic Descriptor Declarations
               1. Characteristic Extended Properties
               3. Client Characteristic Configuration
      4. GATT Feature Requirements — defines the GATT procedures.
         3. Server Configuration
            1. Exchange MTU
         4. Primary Service Discovery
            1. Discover All Primary Services
            2. Discover Primary Service by Service UUID
         5. Relationship Discovery
            1. Find Included Services
         6. Characteristic Discovery
            1. Discover All Characteristics of a Service
            2. Discover Characteristics by UUID
         7. Characteristic Descriptor Discovery
            1. Discover All Characteristic Descriptors
         8. Characteristic Value Read
         9. Characteristic Value Write
            1. Write Without Response
            2. Write Characteristic Value
         10. Characteristic Value Notification
         11. Characteristic Value Indications
         12. Characteristic Descriptors
             1. Read Characteristic Descriptors
             2. Read Long Characteristic Descriptors
             3. Write Characteristic Descriptors
             4. Write Long Characteristic Descriptors
         14. Procedure Timeouts
      6. GAP Interoperability Requirements
         1. BR/EDR GAP Interoperability Requirements
            1. Connection Establishment
         2. LE GAP Interoperability Requirements
            1. Connection Establishment
      7. Defined Generic Attribute Profile Service
         1. Service Changed
   8. Security Manager Specification
      2. Security Manager
         4. Security in Bluetooth Low Energy
            1. Definition of Keys and Values, defines the Identity Resolving Key (IRK)
6. Core System Package [Low Energy Controller volume]
   2. Link Layer Specification
      1. General Description
         3. Device Address
            1. Public Device Address
            2. Random Device Address
               1. Static Device Address
      4. Air Interface Protocol
         4. Non-Connected States
            3. Scanning State
               1. Passive Scanning

[[!BLUETOOTH-SUPPLEMENT6]]

1. Data Types Specification
   1. Data Types Definitions and Formats
      1. Service UUID Data Type
      2. Local Name Data Type
      3. Flags Data Type (defines the Discoverable Mode flags)
      4. Manufacturer Specific Data
      5. TX Power Level
      11. Service Data
      12. Appearance