Web 蓝牙

1. 如果 filter.name 存在，则若 device 的蓝牙设备名不完整或不等于 filter.name，返回 mismatch。

2. 如果 filter.namePrefix 存在，则若 device 的蓝牙设备名不存在或不以 filter.namePrefix 开头，返回 mismatch。

3. 对于 filter.services 中的每个 uuid，若 UA 未接收到广告数据、扩展查询响应，或指示设备支持 UUID 为 uuid 的主（非包含）服务的服务发现响应，则返回 mismatch。

4. 对于 filter["manufacturerData"] 中的每个 manufacturerData，若 device 未广播厂商特定数据，其公司标识符等于 manufacturerData["companyIdentifier"]，且数据匹配 manufacturerData，则返回 mismatch。

5. 对于 filter["serviceData"] 中的每个 serviceData，若 device 未广播服务数据，其 128 位形式的 UUID 等于 serviceData["service"]， 且数据匹配 serviceData，则返回 mismatch。

6. 返回 match。

1. 令 expectedPrefix 为 由字节构成的拷贝，其来源为 filter.dataPrefix。

2. 令 mask 为 由字节构成的拷贝，其来源为 filter.mask。

3. 如果 data 的字节数少于 expectedPrefix，返回 mismatch。

4. 对于 mask 中的每个 1 位，若 data 中对应位不等于 expectedPrefix 中对应位，返回 mismatch。

5. 返回 match。

1. 如果 filter1 的长度小于 filter2 的长度，返回 false。

2. 令 byteIndex 为 0。

3. 当 byteIndex 小于 filter2 的长度时，执行以下子步骤：

   1. 如果 filter1.mask[byteIndex] & filter2.mask[byteIndex] 不等于 filter2.mask[byteIndex]，返回 false。

   2. 如果 filter1.dataPrefix[byteIndex] & filter2.mask[byteIndex] 不等于 filter2.dataPrefix[byteIndex] & filter2.mask[byteIndex]，返回 false。

   3. 将 byteIndex 设为 byteIndex + 1。

4. 返回 true。

1. 令 global 为 this 的相关全局对象。

2. 如果 global 的关联的 Document未被允许使用名为 "bluetooth" 的策略控制特性，则返回以SecurityError拒绝的 promise。

3. 令 promise 为一个新的 promise。

4. 并行执行以下步骤：

   1. 令 devices 为新的空 Array。

   2. 对于 storage.allowedDevices 中的每个 allowedDevice，将表示 allowedDevice@[[device]] 的 BluetoothDevice 对象添加到 devices。

   3. 针对给定的 global 在Bluetooth 任务源上排队一个全局任务，用 devices 解析 promise。

   Note: devices 中的 BluetoothDevice 可能不在蓝牙射频范围内。对于 devices 中的某个 device，可使用 watchAdvertisements() 方法在 device 处于范围内并广播广告包时进行观察。当在某个 device 上触发 advertisementreceived 事件 event 时，可能表示它距离足够近，可以通过调用 event.device.gatt.connect() 建立连接。

5. 返回 promise。

1. 如果 options.exclusionFilters 存在而 options.filters 不存在，返回以TypeError拒绝的 promise。

2. 如果 options.filters 存在且 options.acceptAllDevices 为 true，或 options.filters 不存在且 options.acceptAllDevices 为 false，则返回以TypeError拒绝的 promise。

   Note: 这强制要求 filters 与 acceptAllDevices:true 必须且仅能有一个存在。

3. 令 promise 为一个新的 promise。

4. 并行执行以下步骤：

   1. 请求蓝牙设备，当 options.acceptAllDevices 为 false 时传入 options.filters；否则传入 null。若存在则传入 options.exclusionFilters，否则传入 null；同时传入 options.optionalServices 与 options.optionalManufacturerData，令结果为 devices。

   2. 在Bluetooth 任务源上，针对this的相关全局对象排队一个全局任务以运行以下步骤：

      1. 若上一步抛出异常，拒绝 promise 并终止这些步骤。

      2. 如果 devices 是空序列，拒绝 promise，错误为 NotFoundError， 并终止这些步骤。

      3. 解析 promise，值为 devices[0]。

5. 返回 promise。

1. 令 global 为 storage 的相关全局对象。

2. 令 document 为 global 的关联 Document。

3. 如果 document 未被允许使用名为 "bluetooth" 的策略控制特性，抛出 SecurityError 并终止这些步骤。

4. 检查该算法是否在其相关全局对象具有瞬时激活期间触发；否则抛出 SecurityError 并终止这些步骤。

5. 为将参数从服务名称与别名转换为仅UUID，执行以下子步骤：

   1. 如果 filters !== null && filters.length === 0，抛出 TypeError 并终止这些步骤。

   2. 如果 exclusionFilters !== null && exclusionFilters.length === 0，抛出 TypeError 并终止这些步骤。

   3. 令 uuidFilters 为新的 Array， uuidExclusionFilters 为新的 Array， requiredServiceUUIDs 为新的 Set。

   4. 如果 filters 为 null，则将 requiredServiceUUIDs 设为所有 UUID 的集合。

   5. 如果 filters 不为 null，则对于 filters 中的每个 filter，执行：

      1. 令 canonicalFilter 为规范化 filter 的结果。

      2. 将 canonicalFilter 追加到 uuidFilters。

      3. 将 canonicalFilter.services 中的内容添加到 requiredServiceUUIDs。

   6. 如果 exclusionFilters 不为 null，则对于 exclusionFilter 属于 exclusionFilters 的每个元素，执行：

      1. 令 canonicalExclusionFilter 为规范化 exclusionFilter 的结果。

      2. 将 canonicalExclusionFilter 追加到 uuidExclusionFilters。

   7. 令 optionalServiceUUIDs 为 Array.prototype.map.call(optionalServices, BluetoothUUID.getService)。

   8. 如果任一 BluetoothUUID.getService() 调用抛出异常，抛出该异常并终止这些步骤。

   9. 从 optionalServiceUUIDs 中移除任何在阻止列表中的 UUID。

6. 令 descriptor 为

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

7. 令 state 为 descriptor 的权限状态。

   Note: 在非安全上下文中，state 将为 "denied"，因为强能力不能在非安全上下文使用。

8. 如果 state 为 "denied"，返回 [] 并终止这些步骤。

9. 如果 UA 能证明下一步不可能找到任何设备（例如没有用于扫描的蓝牙适配器，或筛选器不可能匹配任何广告包），UA 可以返回 [] 并终止这些步骤。

10. 令 scanResult 为以 global 与 requiredServiceUUIDs 调用扫描设备的结果。

11. 如果 filters 不为 null，则：

    1. 从 scanResult 中移除未匹配 uuidFilters 中任一筛选器的设备。

    2. 如果 exclusionFilters 不为 null，从 scanResult 中移除 匹配 uuidExclusionFilters 中任一筛选器的设备。

12. 令 navigable 为 document 的navigable。

13. 令 promptId 为新的唯一不透明字符串。

实际上，设备列表会在提示框打开期间动态更新。规范文本目前尚未反映这一点，但该事件可能会带着相同的 promptId 和新的设备列表多次触发。参见 https://github.com/WebBluetoothCG/web-bluetooth/issues/621。

1. 触发“提示已更新”事件，传入 navigable、promptId 和 scanResult。

2. 即使 scanResult 为空，也要提示用户进行选择， 从 scanResult 中选择一个设备，与 descriptor 关联，令结果为 device。

   UA 可以允许用户选择一个不匹配 uuidFilters 的附近设备。

   Note: UA 应显示每台设备的人类可读名称。如果该名称不可用（例如 UA 的蓝牙系统不支持开启隐私的扫描），UA 应允许用户表示兴趣，然后执行不启用隐私的扫描以获取该名称。

3. 移除可导航对象到设备提示的映射[navigable 的navigable id]。

4. UA 可以将 device 添加到 storage。

   Note: 选择某个 device 可能表示用户意图让该设备出现在"bluetooth" 的额外权限数据的 allowedDevices 列表中（至少对当前设置对象），其 mayUseGATT 字段为 true；requiredServiceUUIDs 与 optionalServiceUUIDs 的并集中所有服务出现在其 allowedServices 列表中（以及任何已存在的服务）；并且 optionalManufacturerData 中的厂商代码出现在其 allowedManufacturerData 列表中。

5. 如果 device 为 "denied"，返回 [] 并终止这些步骤。

6. UA 可以选择 填充 Bluetooth 缓存，将 device 内的所有服务添加其中。本步骤中的任何错误均应被忽略。

7. 获取表示 BluetoothDevice 的对象 device 在 this 内，如有异常则向上传递，并令 deviceObj 为结果。

8. 返回 [deviceObj]。

1. 如果 filter 的所有成员均不存在，抛出 TypeError 并终止这些步骤。

2. 令 canonicalizedFilter 为 {}。

3. 如果 filter.services 存在，执行以下子步骤：

   1. 如果 filter.services.length === 0，抛出 TypeError 并终止这些步骤。

   2. 令 services 为 Array.prototype.map.call(filter.services, BluetoothUUID.getService)。

   3. 若任一 BluetoothUUID.getService() 调用抛出异常，抛出该异常并终止这些步骤。

   4. 如果 services 中的任一服务在阻止列表中，抛出 SecurityError 并终止这些步骤。

   5. 将 canonicalizedFilter.services 设为 services。

4. 如果 filter.name 存在，执行以下子步骤。

   1. 如果 filter.name 的UTF-8 编码超过 248 字节，抛出 TypeError 并终止这些步骤。

      Note: 248 是蓝牙设备名中 UTF-8 码元的最大数量。

   2. 将 canonicalizedFilter.name 设为 filter.name。

5. 如果 filter.namePrefix 存在，执行以下子步骤。

   1. 如果 filter.namePrefix.length === 0，或其UTF-8 编码超过 248 字节，抛出 TypeError 并终止这些步骤。

      Note: 248 是蓝牙设备名中 UTF-8 码元的最大数量。

   2. 将 canonicalizedFilter.namePrefix 设为 filter.namePrefix。

6. 将 canonicalizedFilter["manufacturerData"] 设为 []。

7. 如果 filter["manufacturerData"] 存在且 filter["manufacturerData"].length === 0，抛出 TypeError 并终止这些步骤。

8. 对于 filter["manufacturerData"] 中的每个 manufacturerData，执行以下子步骤：

   1. 如果 manufacturerData 是被阻止的厂商数据筛选器，抛出 SecurityError 并终止这些步骤。

   2. 如果在 canonicalizedFilter["manufacturerData"] 中存在对象 existing，且 existing["companyIdentifier"] === manufacturerData["companyIdentifier"]，抛出 TypeError 并终止这些步骤。

   3. 令 canonicalizedManufacturerDataFilter 为规范化 manufacturerData 的结果，并转换为 ECMAScript 值。若抛出异常，传播该异常并终止这些步骤。

   4. 将 canonicalizedManufacturerDataFilter["companyIdentifier"] 设为 manufacturerData["companyIdentifier"]。

   5. 将 canonicalizedManufacturerDataFilter 追加到 canonicalizedFilter["manufacturerData"]。

9. 将 canonicalizedFilter.serviceData 设为 []。

10. 如果 filter["serviceData"] 存在且 filter["serviceData"].length === 0，抛出 TypeError 并终止这些步骤。

11. 对于 filter["serviceData"] 中的每个 serviceData，执行以下子步骤：

    1. 令 service 为 BluetoothUUID.getService(serviceData["service"])。 若抛出异常，传播该异常并终止这些步骤。

    2. 如果 service在阻止列表中，抛出 SecurityError 并终止这些步骤。

    3. 令 canonicalizedServiceDataFilter 为规范化 serviceData 的结果，并转换为 ECMAScript 值。若抛出异常，传播该异常并终止这些步骤。

    4. 将 canonicalizedServiceDataFilter["service"] 设为 service。

    5. 将 canonicalizedServiceDataFilter 追加到 canonicalizedFilter["serviceData"]。

12. 返回 canonicalizedFilter。

1. 如果 filter.dataPrefix 不存在，则令 dataPrefix 为空字节序列。否则，执行以下子步骤：

   1. 令 dataPrefix 为由字节构成的拷贝，其来源为 filter.dataPrefix。

   2. 如果 dataPrefix 的长度为 0，抛出 TypeError 并终止这些步骤。

2. 如果 filter.mask 存在，则令 mask 为 由字节构成的拷贝，其来源为 filter.mask。否则，令 mask 为与 dataPrefix 相同长度的 0xFF 字节序列。

3. 如果 mask 的长度与 dataPrefix 不同，抛出 TypeError 并终止这些步骤。

4. 返回 {dataPrefix: new Uint8Array(|dataPrefix|), mask: new Uint8Array(|mask|)}。

1. 如果 UA 最近使用一个 UUID 集合扫描过设备，且该集合是当前扫描所用 UUID 集合的超集，则 UA 可以返回那次扫描的结果并中止这些步骤。

   TODO：确定具体的时间长度。

2. 令 nearbyDevices 为一组蓝牙设备，初始等于与 UA 已连接（具有 ATT 承载体）的设备集合。

3. 令 topLevelTraversable 为 global 的 navigable 的 顶层可遍历对象。

4. 令 simulatedBluetoothDevices 为一个空列表。

5. 如果 topLevelTraversable 具有模拟蓝牙适配器，则令 simulatedBluetoothDevices 为其获取映射值后的 模拟蓝牙设备映射的结果。

   支持异步设备发现。

6. 如果 UA 支持 LE 传输，执行常规发现流程（General Discovery Procedure），但 UA 可以包含未设置可发现模式（Discoverable Mode）标志的设备，并将发现的蓝牙设备加入 nearbyDevices。UA 应启用隐私功能（Privacy Feature）。

   被动扫描（passive scanning）与隐私功能都可避免泄露唯一且不可变的设备 ID。我们本应要求 UA 使用其中之一，但没有任何操作系统 API 似乎暴露了这两者。并且由于蓝牙不要求中心设备（Central）支持观察流程（Observation Procedure），因此也很难使用被动扫描。

7. 如果 UA 支持 BR/EDR 传输，执行设备发现流程（Device Discovery Procedure）并将发现的蓝牙设备加入 nearbyDevices。

   所有形式的 BR/EDR 查询/发现似乎都会泄露唯一且不可变的设备地址。

8. 令 result 为一组蓝牙设备，初始为空。

9. 对 nearbyDevices 与 simulatedBluetoothDevices 中的每个蓝牙设备 device，执行以下子步骤：

   1. 如果 device 的支持的物理传输包含 LE，且其蓝牙设备名是不完整的或缺失，UA 应执行名称发现流程（Name Discovery Procedure）以获取完整名称。

   2. 如果 device 广播的服务 UUID与服务 UUID 集合有非空交集，则将 device 加入 result 并中止这些子步骤。

      注意：对于 BR/EDR 设备，无法在扩展查询响应（Extended Inquiry Response）中区分 GATT 与非 GATT 服务。如果站点按某个非 GATT 服务的 UUID 进行过滤，用户可能会在 requestDevice 的结果中选择一个本 API 无法与之交互的设备。

   3. UA 可以连接到 device 并填充蓝牙缓存，包含所有 UUID 位于服务 UUID 集合中的服务。如果 device 的支持的物理传输包含 BR/EDR，则除了标准 GATT 流程外，UA 也可以在填充缓存时使用服务发现协议（Searching for Services）。

      注意：连接所有附近设备以发现服务会消耗电量并可能降低蓝牙射频的其它用途。UA 仅应在有理由认为设备值得关注时才对其进行额外服务发现。

      UA 也应帮助开发者避免依赖这种额外的发现行为。例如，假设开发者之前已连接过某设备，因此 UA 知道该设备完整的支持服务集合。若该开发者随后使用未广播的 UUID 进行过滤，即便在其他用户的机器上该过滤器很可能会将该设备排除，对话框中仍可能包含该设备。UA 可以提供一个开发者选项，在发生这种情况时进行警告，或在匹配过滤器时仅包含已广播的服务。

   4. 如果蓝牙缓存中包含 device 内已知存在、且其 UUID 位于服务 UUID 集合中的服务，UA 可以将 device 加入 result。

10. 从扫描中返回 result。

1. 令 grantedServiceUUIDs 为新的 Set。

2. 将 requiredServiceUUIDs 的内容添加到 grantedServiceUUIDs。

3. 将 optionalServiceUUIDs 的内容添加到 grantedServiceUUIDs。

4. 在 storage.allowedDevices 中查找元素 allowedDevice，其满足 device 等于 allowedDevice@[[device]]。 如果找到，执行以下子步骤：

   1. 将 allowedDevice.allowedServices 的内容添加到 grantedServiceUUIDs。

   如果未找到，执行以下子步骤：

   1. 令 allowedDevice.deviceId 为一个唯一 ID，其唯一性取决于 UA 能在何种程度上判定两次蓝牙连接来自同一设备，以及 用户希望在何种程度上将这一事实暴露给脚本。

5. 将 allowedDevice.allowedServices 设为 grantedServiceUUIDs。

6. 将 allowedDevice.mayUseGATT 设为 true。

1. 令 global 为 this 的相关全局对象。

2. 如果 global 的关联的 Document未被允许使用名为 "bluetooth" 的策略控制特性，则针对给定的 global 在Bluetooth 任务源上排队一个全局任务以解析 promise 为 false，并终止这些步骤。

3. 如果用户已将 UA 配置为对当前来源从该函数返回特定答案，则排队一个任务以解析 promise 为该配置的答案，并终止这些步骤。

   注意：如果 Web Bluetooth 权限已被用户阻止，UA 可以将 promise 解析为 false。

4. 令 simulatedBluetoothAdapter 为 this 的navigable 的 顶层可遍历对象的 模拟蓝牙适配器。

5. 如果 simulatedBluetoothAdapter 非空，

   1. 如果 simulatedBluetoothAdapter 的适配器状态为 "absent"，则针对给定的 global 在Bluetooth 任务源上排队一个全局任务以解析 promise 为 false。

   2. 如果 simulatedBluetoothAdapter 的LE 支持状态为 false，则针对给定的 global 在Bluetooth 任务源上排队一个全局任务以解析 promise 为 false。

   3. 否则，针对给定的 global 在Bluetooth 任务源上排队一个全局任务以解析 promise 为 true。

   4. 终止这些步骤。

6. 如果 UA 运行在具有蓝牙射频的系统上，则针对给定的 global 在Bluetooth 任务源上排队一个全局任务以解析 promise 为 true，无论蓝牙射频的供电状态如何。

7. 否则，针对给定的 global 在Bluetooth 任务源上排队一个全局任务以解析 promise 为 false。

   注意：该 promise 被并行解析，以便 UA 调用其他系统来确定蓝牙是否可用。

1. 令 storage（一个 BluetoothPermissionStorage）为 "bluetooth" 针对额外权限数据的 当前设置对象。

2. 在 storage.allowedDevices 中查找其 allowedDevice.[[device]] 与 device为同一设备的 allowedDevice。若没有此对象，则抛出 SecurityError 并中止这些步骤。

3. 若在 context.[[deviceInstanceMap]] 中不存在与 device为同一设备的键，则执行以下子步骤：

   1. 令 result 为 BluetoothDevice 的新实例。

   2. 将 result 的所有可选字段初始化为 null。

   3. 将 result.[[context]] 初始化为 context。

   4. 将 result.[[representedDevice]] 初始化为 device。

   5. 将 result.id 初始化为 allowedDevice.deviceId， 并将 result.[[allowedServices]] 初始化为 allowedDevice.allowedServices。

   6. 若 device 具有部分或完整蓝牙设备名，则将 result.name 设为该字符串。

   7. 将 result.watchingAdvertisements 初始化为 false。

   8. 在 context.[[deviceInstanceMap]] 中添加从 device 到 result 的映射。

4. 返回 context.[[deviceInstanceMap]] 中以与 device为同一设备为键的值。

1. 如果针对 this 的"bluetooth"的额外权限数据（对应其相关设置对象）的 AllowedBluetoothDevice 列表 allowedDevices 中存在 allowedDevice，满足 allowedDevice.[[device]] 与 this.[[representedDevice]] 为同一设备，且 allowedDevice.mayUseGATT 等于 true，则返回 this.[[gatt]]。

2. 否则，返回 null。

1. 令 device 为目标 BluetoothDevice 对象。

2. 令 storage 为当前脚本执行环境中的 BluetoothPermissionStorage 对象。

3. 使用 storage从存储中移除 device。

4. 解析 promise。

1. 令 global 为相关全局对象，对应 this。

2. 如果 options.signal 存在，则执行以下子步骤：

   1. 如果 options.signal 已中止，则以 this为对象中止 watchAdvertisements 并中止这些步骤。

   2. 向 options.signal 添加以下中止步骤：

      1. 以 this为对象中止 watchAdvertisements。

      2. 拒绝 promise，错误为 AbortError。

3. 若 this.[[watchAdvertisementsState]] 为：

   'not-watching'

   1. 将 this.[[watchAdvertisementsState]] 设为 'pending-watch'。

   2. 将以下步骤入队至广告监视管理器，但当 this.[[watchAdvertisementsState]] 变为 not-watching 时中止：

      1. 确保 UA 正在扫描该设备的广告。UA 不应筛除同一设备的“重复”广告。

      2. 若 UA 启用扫描失败，则在给定 global 的 Bluetooth 任务源上排队一个全局任务以执行以下步骤，并中止这些步骤：

         1. 将 this.[[watchAdvertisementsState]] 设为 'not-watching'。

         2. 拒绝 promise，错误为下列之一：

            UA 不支持扫描广告

            NotSupportedError

            蓝牙已关闭

            InvalidStateError

            其他原因

            UnknownError

      3. 在给定 global 的 Bluetooth 任务源上排队一个全局任务以执行以下步骤，但当 满足中止条件（即 this.[[watchAdvertisementsState]] 变为 not-watching）时中止：

         1. 将 this.[[watchAdvertisementsState]] 设为 watching。

         2. 将 this.watchingAdvertisements 设为 true。

         3. 解析 promise，值为 undefined。

   'pending-watch'

   1. 拒绝 promise，错误为 InvalidStateError。

   'watching'

   1. 解析 promise，值为 undefined。

4. 若已中止，拒绝 promise，错误为 AbortError。

Note: 扫描会消耗电量，因此网站应避免不必要地监视广告，并应使用其 AbortController 尽快停止耗电。

1. 将 this.[[watchAdvertisementsState]] 设为 'not-watching'。

2. 将 device.watchingAdvertisements 设为 false。

3. 将以下步骤入队到广告监视管理器：

   1. 如果整个 UA 中不再有任何 BluetoothDevice 的 watchingAdvertisements 为 true，UA 应停止扫描广告。否则，若不再有任何与 this 表示同一设备的 BluetoothDevice 的 watchingAdvertisements 为 true，UA 应重新配置扫描以避免接收该设备的报告。

1. 对每个位于 bluetooth.[[deviceInstanceMap]] 中的 device 执行以下步骤：

   1. 如果 device.[[watchAdvertisementsState]] 为 pending-watch 或 watching，则以 device为对象运行中止 watchAdvertisements。

1. 尝试使用任何GATT 流程的序列，只要[BLUETOOTH42]规定它们将返回足够的信息，即可将缓存中所有匹配的条目标记为已知存在或已知不存在。按§ 6.7 错误处理所述处理错误。

2. 如果上一步返回错误，则从本算法返回该错误。

1. 令 global 为 deviceObj 的相关全局对象。

2. 填充蓝牙缓存，使其包含匹配该描述的条目。

3. 如果上一步返回错误，则在给定 global 的Bluetooth 任务源上排队一个全局任务以拒绝promise并附带该错误，然后中止这些步骤。

4. 令 entries 为与该描述匹配的“已知存在”的缓存条目序列。

5. 令 context 为 deviceObj.[[context]]。

6. 令 result 为一个新的序列。

7. 对于 entries 中的每个 entry：

   1. 如果 entry 在 context.[[attributeInstanceMap]] 中没有关联的 Promise<BluetoothGATT*> 实例，则视 entry 的类型（服务、特征值或描述符），分别创建一个表示该条目的 BluetoothRemoteGATTService、创建一个表示该条目的 BluetoothRemoteGATTCharacteristic，或者创建一个表示该条目的 BluetoothRemoteGATTDescriptor，并在 context.[[attributeInstanceMap]] 中添加从 entry 到所得到的Promise的映射。

   2. 将与 entry 关联的 Promise<BluetoothGATT*> 实例追加到 context.[[attributeInstanceMap]] 中对应的 result。

8. 在给定 global 的Bluetooth 任务源上排队一个全局任务，以解析promise，其值为等待所有result元素完成后的结果。

BluetoothDevice

obj.[[representedDevice]]

BluetoothRemoteGATTService

obj.[[representedService]]

BluetoothRemoteGATTCharacteristic

obj.[[representedCharacteristic]]

BluetoothRemoteGATTDescriptor

obj.[[representedDescriptor]]

1. 如果存在 uuid，则将其设为 uuidCanonicalizer(uuid)。如果 uuidCanonicalizer 抛出了异常，返回一个以该异常拒绝的 promise，并中止这些步骤。

2. 如果存在 uuid 且其在阻止列表中，返回一个被拒绝的 promise，错误为SecurityError，并中止这些步骤。

3. 令 deviceObj 为（取决于 attribute 的类型）：

   BluetoothDevice

   attribute

   BluetoothRemoteGATTService

   attribute.device

   BluetoothRemoteGATTCharacteristic

   attribute.service.device

4. 如果 deviceObj.gatt.connected 为 false，返回一个被拒绝的 promise，错误为NetworkError，并中止这些步骤。

5. 如果 Represented(attribute) 为 null，返回一个被拒绝的 promise，错误为InvalidStateError，并中止这些步骤。

   Note: 当某个服务或特征值从设备上被移除或因断开连接而失效后又被再次使用时，就会出现这种情况。

6. 在 deviceObj 中查询蓝牙缓存，查找满足以下条件的条目：

   • 位于 Represented(attribute) 之内，

   • 其类型由 child type 描述，

   • 其 UUID 不在阻止列表中，

   • 如果存在 uuid，则其 UUID 等于 uuid，

   • 如果存在 allowedUuids 且不为 "all"，则其 UUID 在 allowedUuids 中，且

   • 如果设置了 single 标志，则只取这些中的第一个。

   令 promise 为该结果。

7. 当promise完成并给出 result 时，运行以下步骤：

   • 如果 result 为空，抛出NotFoundError。

   • 否则，如果设置了 single 标志，返回 result 的第一个（也是唯一一个）元素。

   • 否则，返回 result。

1. 令 global 为this 的相关全局对象。

2. 如果this.device.[[representedDevice]] 为 null，返回一个被拒绝的 promise，错误为“NetworkError”的 DOMException。

3. 如果 UA 当前正在使用蓝牙系统，它可以返回一个被拒绝的 promise，错误为“NetworkError”的 DOMException。

   实现可能能够避免该NetworkError，但目前站点需要串行化对该 API 的使用，和/或为用户提供重试失败操作的方法。[Issue #188]

4. 令 promise 为一个新的 promise。

5. 如果this.connected 为 true，则解析promise，其值为this，并返回 promise。

6. 将 promise 添加到this.[[activeAlgorithms]]。

7. 并行运行以下步骤：

   1. 如果 global 的navigable 的 顶层可遍历对象具有模拟蓝牙适配器，则运行以下步骤：

      1. 触发一次 gatt 连接尝试事件，传入 global 的navigable 与this.device。

      2. 如果this.[[automatedGATTConnectionResponse]] 为 "not-expected"，将其设为 "expected"。

      3. 如果this.[[automatedGATTConnectionResponse]] 为 "expected"，则等待其改变。

      4. 令 response 为this.[[automatedGATTConnectionResponse]]。

      5. 将this.[[automatedGATTConnectionResponse]] 设为 "not-expected"。

      6. 如果 response 不为 0，执行以下子步骤：

         1. 从this.[[activeAlgorithms]] 中移除 promise。

         2. 在给定 global 的Bluetooth 任务源上排队一个全局任务，以拒绝promise，错误为“NetworkError”的 DOMException，并中止这些步骤。

   2. 否则，运行以下步骤：

      1. 如果this.device.[[representedDevice]] 尚无ATT 承载体，执行以下子步骤：

         1. 尝试使用GAP 互操作性要求中的“连接建立”所述流程创建一个ATT 承载体。如果 promise 从this.[[activeAlgorithms]] 中被移除，则中止此次尝试。

            注意：如果未接收到可连接的广播，这些流程可能会无限等待。如果网站不再希望连接，应调用disconnect()。

         2. 如果此次尝试因 promise 从this.[[activeAlgorithms]] 中移除而被中止，则在给定 global 的Bluetooth 任务源上排队一个全局任务以拒绝promise，错误为“AbortError”的 DOMException，并中止这些步骤。

         3. 如果此次尝试因其他原因失败，则在给定 global 的Bluetooth 任务源上排队一个全局任务以拒绝promise，错误为“NetworkError”的 DOMException，并中止这些步骤。

         4. 使用交换 MTU（Exchange MTU）流程来协商最大的支持 MTU。忽略此步骤中的任何错误。

         5. UA 可以尝试使用BR/EDR 绑定流程或LE 绑定流程与远程设备建立绑定。

            Note: 通常我们更希望由网站控制是否以及何时进行绑定，但 Core Bluetooth 平台 API 不提供让 UA 实现此控制的方式。拥有绑定比没有绑定更安全，因此本规范允许 UA 在可能的平台上机会性地创建绑定。这可能会导致在建立连接时（而不是访问受限特征值时）出现一个用户可见的配对对话框。

   3. 在给定 global 的Bluetooth 任务源上排队一个全局任务，以执行以下子步骤：

      1. 如果 promise 不在this.[[activeAlgorithms]] 中，拒绝promise，错误为“AbortError”的 DOMException，回收该连接（位于 this.device.[[representedDevice]]），并中止这些步骤。

      2. 从this.[[activeAlgorithms]] 中移除 promise。

      3. 如果this.device.[[representedDevice]] 为 null，拒绝promise，错误为“NetworkError”的 DOMException，回收该连接（位于 this.device.[[representedDevice]]），并中止这些步骤。

      4. 将this.connected 设为 true。

      5. 解析promise，其值为this。

8. 返回 promise。

1. 清空 this.[[activeAlgorithms]]，以中止任何活动的 connect() 调用。

2. 如果 this.connected 为 false，中止这些步骤。

3. 清理已断开连接的设备 this.device。

4. 令 device 为 this.device.[[representedDevice]]。

5. 回收device 的连接。

1. 如果 UA 内外部的非本 API 系统正在使用 device 的ATT 承载体，则中止本算法。

2. 对于整个 UA 中的所有 BluetoothDevice deviceObj：

   1. 如果 deviceObj.[[representedDevice]] 不是与 device同一设备，则继续下一个 deviceObj。

   2. 如果 deviceObj.gatt.connected 为 true，中止本算法。

   3. 如果 deviceObj.gatt.[[activeAlgorithms]] 包含一次connect()调用的Promise，中止本算法。

3. 销毁 device 的ATT 承载体。

为了在 promise 周围创建一个 gattServer-连接检查包装器，UA 必须：

1. 如果 gattServer.connected 为 true，将 promise 添加到 gattServer.[[activeAlgorithms]]。

2. 对promise做出反应：

   • 如果 promise 以值 result 得到满足，则：

     1. 如果 promise 在 gattServer.[[activeAlgorithms]] 中，移除它并返回 result。

     2. 否则，抛出NetworkError。

        注意：抛出该错误是因为 gattServer 在主算法执行期间被断开。

   • 如果 promise 以原因 error 被拒绝，则：

     1. 如果 promise 在 gattServer.[[activeAlgorithms]] 中，移除它并抛出 error。

     2. 否则，抛出NetworkError。

        注意：抛出该错误是因为 gattServer 在主算法执行期间被断开。

1. 如果 this.device.[[allowedServices]] 不为 "all"，且 service 不在 this.device.[[allowedServices]] 中，则返回一个被拒绝的 promise，错误为SecurityError，并中止这些步骤。

2. 返回 GetGATTChildren(attribute=this.device,
   single=true,
   uuidCanonicalizer=BluetoothUUID.getService,
   uuid=service,
   allowedUuids=this.device.[[allowedServices]],
   child type="GATT Primary Service")

1. 如果 this.device.[[allowedServices]] 不为 "all"，且存在 service 且其不在 this.device.[[allowedServices]] 中，则返回一个被拒绝的 promise，错误为SecurityError，并中止这些步骤。

2. 返回 GetGATTChildren(attribute=this.device,
   single=false,
   uuidCanonicalizer=BluetoothUUID.getService,
   uuid=service,
   allowedUuids=this.device.[[allowedServices]],
   child type="GATT Primary Service")

1. 令 global 为this 的相关全局对象。

2. 令 promise 为一个新的 promise。

3. 并行运行以下步骤：

   1. 令 result 为 BluetoothRemoteGATTService 的新实例，其 [[representedService]] 槽位初始化为 service。

   2. 获取表示该设备的 BluetoothDevice，即 service 所在的设备，并令 device 为结果。

   3. 如果上一步抛出错误，则在给定 global 的 Bluetooth 任务源上排队一个全局任务以拒绝promise 并附带该错误，然后中止这些步骤。

   4. 用 device 初始化 result.device。

   5. 用 service 的 UUID 初始化 result.uuid。

   6. 如果 service 是主服务，则将 result.isPrimary 设为 true；否则设为 false。

   7. 在给定 global 的 Bluetooth 任务源上排队一个全局任务，以解析promise，其值为 result。

4. 返回 promise。

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

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

1. 令 global 为this 的相关全局对象。

2. 令 promise 为一个新的 promise。

3. 并行运行以下步骤：

   1. 令 result 为 BluetoothRemoteGATTCharacteristic 的新实例，其 [[representedCharacteristic]] 槽位初始化为 characteristic。

   2. 用出现 characteristic 的 Service 的表示实例，初始化 result.service<。

   3. 用 characteristic 的 UUID 初始化 result.uuid。

   4. 基于特征值创建一个 BluetoothCharacteristicProperties 实例 characteristic，并令 properties 为其结果。

   5. 如果上一步返回错误，则在给定 global 的 Bluetooth 任务源上排队一个全局任务以拒绝promise 并附带该错误，然后中止这些步骤。

   6. 将 result.properties 初始化为 properties。

   7. 将 result.value 初始化为 null。如果可用，UA 可以将 result.value 初始化为一个新的 DataView，其封装了一个新的 ArrayBuffer，包含最近一次从 characteristic 读取到的值。

   8. 在给定 global 的 Bluetooth 任务源上排队一个全局任务，以解析promise，其值为 result。

4. 返回 promise。

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

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

1. 令 global 为this 的相关全局对象。

2. 令 gatt 为this.service.device.gatt。

3. 如果this.uuid 被列入读取阻止列表，则返回一个被拒绝的 promise，错误为“SecurityError” 的 DOMException，并中止这些步骤。

4. 如果 gatt.connected 为 false，则返回一个被拒绝的 promise，错误为“NetworkError” 的 DOMException，并中止这些步骤。

5. 令 characteristic 为this.[[representedCharacteristic]]。

6. 如果 characteristic 为 null，则返回一个被拒绝的 promise，错误为“InvalidStateError” 的 DOMException，并中止这些步骤。

7. 返回一个围绕新 promise promise 的 gatt-连接检查包装器，并并行运行以下步骤：

   1. 如果 characteristic 的属性中未设置 Read 位，则在给定 global 的 Bluetooth 任务源上排队一个全局任务以拒绝promise，错误为“NotSupportedError” 的 DOMException，并中止这些步骤。

   2. 如果 global 的navigable 的 顶层可遍历对象具有模拟蓝牙适配器，则运行以下步骤：

      1. 如果this.[[automatedCharacteristicReadResponse]] 不为 "not-expected"，则在给定 global 的 Bluetooth 任务源上排队一个全局任务以 拒绝 promise，错误为“InvalidStateError” 的 DOMException，并中止这些步骤。

      2. 触发一个模拟的特征值事件，传入 global 的 navigable、this.device、characteristic 和 read。

      3. 将this.[[automatedCharacteristicReadResponse]] 设为 "expected"，并等待其改变。

      4. 令 response 为this.[[automatedCharacteristicReadResponse]]。

      5. 将this.[[automatedCharacteristicReadResponse]] 设为 "not-expected"。

      6. 如果 response 不为 0，则执行以下子步骤：

         1. 在给定 global 的 Bluetooth 任务源上排队一个全局任务以拒绝 promise，错误为“NetworkError” 的 DOMException，并中止这些步骤。

      7. 否则，令 buffer 为一个新的 ArrayBuffer，其中包含 this.[[automatedCharacteristicReadResponseData]]。

   3. 否则，运行以下步骤：

      1. 如果 UA 当前正在使用蓝牙系统，它可以在给定 global 的 Bluetooth 任务源上排队一个全局任务以拒绝 promise，错误为“NetworkError” 的 DOMException，并中止这些步骤。

         实现可能能够避免该 NetworkError，但目前站点需要串行化使用该 API，和/或为用户提供重试失败操作的方法。[Issue #188]

      2. 使用特征值读取（Characteristic Value Read）流程中的任意子流程来获取 characteristic 的值，并令 buffer 为一个新的 ArrayBuffer，其中保存所取回的值。 错误按§ 6.7 错误处理进行处理。

   4. 在给定 global 的 Bluetooth 任务源上排队一个全局任务以执行以下步骤：

      1. 如果 promise 不在 gatt.[[activeAlgorithms]] 中，则拒绝 promise，错误为“NetworkError” 的 DOMException，并中止这些步骤。

      2. 如果上述子流程返回错误，则拒绝 promise 并附带该错误，中止这些步骤。

      3. 将用 buffer 创建的新的 DataView 赋给 this.value。

      4. 触发一个事件，名称为“characteristicvaluechanged”，其 bubbles 属性初始化为 true，目标为 this。

      5. 解析 promise，其值为 this.value。

1. 令 global 为 this 的相关全局对象。

2. 令 gatt 为 this.service.device.gatt。

3. 如果 this.uuid 被列入写入阻止列表，则返回一个被拒绝的 promise，错误为“SecurityError” 的 DOMException，并中止这些步骤。

4. 令 bytes 为由 value 持有字节的拷贝。

5. 如果 bytes 长度超过 512 字节（参见长属性值中的属性最大长度），则返回一个被拒绝的 promise，错误为“InvalidModificationError” 的 DOMException，并中止这些步骤。

6. 如果 gatt.connected 为 false，则返回一个被拒绝的 promise，错误为“NetworkError” 的 DOMException，并中止这些步骤。

7. 令 characteristic 为 this.[[representedCharacteristic]]。

8. 如果 characteristic 为 null，则返回一个被拒绝的 promise，错误为“InvalidStateError” 的 DOMException，并中止这些步骤。

9. 返回一个围绕新 promise promise 的 gatt-连接检查包装器，并并行运行以下步骤。

   1. 断言：response 取值为 "required"、"never" 或 "optional" 之一。

   2. 如果 global 的navigable 的 顶层可遍历对象具有模拟蓝牙适配器，则运行以下步骤：

      1. 如果this.[[automatedCharacteristicWriteResponse]] 不为 "not-expected"，则在给定 global 的 Bluetooth 任务源上排队一个全局任务以 拒绝 promise，错误为“InvalidStateError” 的 DOMException，并中止这些步骤。

      2. 触发一个模拟的特征值事件，传入 global 的 navigable、this.device、characteristic、write 和 bytes。

      3. 将this.[[automatedCharacteristicWriteResponse]] 设为 "expected"，并等待其改变。

      4. 令 response 为this.[[automatedCharacteristicWriteResponse]]。

      5. 将this.[[automatedCharacteristicWriteResponse]] 设为 "not-expected"。

      6. 如果 response 不为 0，则执行以下子步骤：

         1. 在给定 global 的 Bluetooth 任务源上排队一个全局任务以拒绝 promise，错误为“NetworkError” 的 DOMException，并中止这些步骤。

   3. 否则，运行以下步骤：

      1. 如果 UA 当前正在使用蓝牙系统，它可以在给定 global 的 Bluetooth 任务源上排队一个全局任务以拒绝 promise，错误为“NetworkError” 的 DOMException，并中止这些步骤。

         实现可能能够避免该 NetworkError，但目前站点需要串行化使用该 API，和/或为用户提供重试失败操作的方法。[Issue #188]

      2. 通过执行以下步骤将 bytes 写入 characteristic：

         如果 response 为 "required"

         使用 写特征值（Write Characteristic Value） 流程。

         如果 response 为 "never"

         使用 无响应写（Write Without Response） 流程。

         否则

         使用特征值写入（Characteristic Value Write）流程中的任意子流程组合。

         错误按§ 6.7 错误处理进行处理。

   4. 在 global 上使用 Bluetooth 任务源排队一个全局任务以执行以下步骤：

      1. 如果 promise 不在 gatt.[[activeAlgorithms]] 中，则拒绝 promise，错误为“NetworkError” 的 DOMException，并中止这些步骤。

      2. 如果上述流程返回错误，则拒绝 promise 并附带该错误，中止这些步骤。

      3. 将 this.value 设为一个新的 DataView，其封装了一个新的 ArrayBuffer，其中包含 bytes。

      4. 解析 promise，其值为 undefined。

WriteCharacteristicValue( this=this,
value=value,
response="required")

WriteCharacteristicValue( this=this,
value=value,
response="never")

1. 令 global 为this 的相关全局对象。

2. 令 gatt 为this.service.device.gatt。

3. 如果this.uuid 被列入读取阻止列表，则返回一个被拒绝的 promise，错误为“SecurityError” 的 DOMException。

4. 如果 gatt.connected 为 false，则返回一个被拒绝的 promise，错误为“NetworkError” 的 DOMException。

5. 令 characteristic 为this.[[representedCharacteristic]]。

6. 如果 characteristic 为 null，则返回一个被拒绝的 promise，错误为“InvalidStateError” 的 DOMException。

7. 返回一个围绕新 promise promise 的 gatt-连接检查包装器，并并行运行以下步骤。

   1. 如果 characteristic 的属性中既未设置 Notify 位也未设置 Indicate 位，则在给定 global 的 Bluetooth 任务源上排队一个全局任务以拒绝 promise，错误为 NotSupportedError，并中止这些步骤。

   2. 如果 characteristic 的活动通知上下文集合包含 navigator.bluetooth，则在给定 global 的 Bluetooth 任务源上排队一个全局任务以解析 promise，其值为this，并中止这些步骤。

   3. 如果 global 的navigable 的 顶层可遍历对象具有模拟蓝牙适配器，则运行以下步骤：

      1. 如果this.[[automatedCharacteristicSubscribeToNotificationsResponse]] 不为 "not-expected"，则在给定 global 的 Bluetooth 任务源上排队一个全局任务以 拒绝 promise，错误为“InvalidStateError” 的 DOMException，并中止这些步骤。

      2. 触发一个模拟的特征值事件，传入 global 的 navigable、this.device、characteristic 与 subscribe-to-notifications。

      3. 将this.[[automatedCharacteristicSubscribeToNotificationsResponse]] 设为 "expected"，并等待其改变。

      4. 令 response 为this.[[automatedCharacteristicSubscribeToNotificationsResponse]]。

      5. 将this.[[automatedCharacteristicSubscribeToNotificationsResponse]] 设为 "not-expected"。

      6. 如果 response 不为 0，则执行以下子步骤：

         1. 在给定 global 的 Bluetooth 任务源上排队一个全局任务以拒绝 promise，错误为“NetworkError” 的 DOMException，并中止这些步骤。

      7. 否则，令 success 为 true。

   4. 否则，运行以下步骤：

      1. 如果 UA 当前正在使用蓝牙系统，它可以在给定 global 的 Bluetooth 任务源上排队一个全局任务以拒绝 promise，错误为“NetworkError” 的 DOMException，并中止这些步骤。

         实现可能能够避免该 NetworkError，但目前站点需要串行化使用该 API，和/或为用户提供重试失败操作的方法。[Issue #188]

      2. 如果该特征值具有客户端特征值配置（Client Characteristic Configuration） 描述符，则使用任意特征值描述符（Characteristic Descriptors）流程，确保在 characteristic 的客户端特征值配置描述符中设置了 Notification 或 Indication 位之一，并与 characteristic 的属性中的约束相匹配。UA 应避免同时设置两位；若两位均被设置，则必须对值变更事件去重。错误按§ 6.7 错误处理进行处理。

         注意：某些设备具有包含 Notify 或 Indicate 位的特征值属性，但却没有客户端特征值配置描述符。这些不符合标准的特征值往往无条件地发送通知或指示，因此本规范允许应用直接订阅其消息。

      3. 如果上述流程成功，则令 success 为 true。

   5. 如果 success 为 true，则将 navigator.bluetooth 加入 characteristic 的活动通知上下文集合。

   6. 在给定 global 的 Bluetooth 任务源上排队一个全局任务以执行以下步骤：

      1. 如果 promise 不在 gatt.[[activeAlgorithms]] 中，则拒绝 promise，错误为“NetworkError” 的 DOMException，并中止这些步骤。

      2. 如果上述流程返回错误，则拒绝 promise 并附带该错误，中止这些步骤。

      3. 解析 promise，其值为this。

1. 令 characteristic 为 this.[[representedCharacteristic]]。

2. 如果 characteristic 为 null，返回一个被拒绝的 promise，错误为 InvalidStateError，并中止这些步骤。

3. 如果 characteristic 的 活动通知上下文集合（active notification context set） 包含 navigator.bluetooth， 则将其移除。

   1. 如果 global 的 navigable 的 顶层可遍历对象的 模拟蓝牙适配器 非空，则运行以下步骤：

      1. 如果 this 的 [[automatedCharacteristicUnsubscribeFromNotificationsResponse]] 不为 "not-expected"， 则在给定 global 的 全局任务队列中，基于 Bluetooth 任务源 拒绝 promise，错误为“InvalidStateError” 的 DOMException，并中止这些步骤。

      2. 触发一个模拟的特征值事件，传入 global 的 navigable、this 的 device、 characteristic 以及 unsubscribe-from-notifications。

      3. 将 this 的 [[automatedCharacteristicUnsubscribeFromNotificationsResponse]] 设为 "expected"， 并等待其改变。

      4. 令 response 为 this 的 [[automatedCharacteristicUnsubscribeFromNotificationsResponse]]。

      5. 将 this 的 [[automatedCharacteristicUnsubscribeFromNotificationsResponse]] 设为 "not-expected"。

      6. 如果 response 不为 0，则执行以下子步骤：

         1. 在给定 global 的 全局任务队列中，基于 Bluetooth 任务源 拒绝 promise，错误为“NetworkError” 的 DOMException，并中止这些步骤。

   2. 否则，运行以下步骤：

      1. 如果 characteristic 的 活动通知上下文集合 变为空，且该特征值具有 客户端特征值配置（Client Characteristic Configuration） 描述符，则 UA 应使用任意 特征值描述符（Characteristic Descriptors） 流程清除 characteristic 的 客户端特征值配置 描述符中的 Notification 与 Indication 位。

4. 在全局任务队列中排队一个任务，基于 Bluetooth 任务源，给定 this 的 相关全局对象，以解析 promise，其值为 this。

1. 令 propertiesObj 为 BluetoothCharacteristicProperties 的一个新实例。

2. 令 properties 为 characteristic 的特征值属性。

3. 根据 properties 中相应的比特，初始化 propertiesObj 的各属性：

   Attribute	Bit
   broadcast	Broadcast
   read	Read
   writeWithoutResponse	Write Without Response
   write	Write
   notify	Notify
   indicate	Indicate
   authenticatedSignedWrites	Authenticated Signed Writes

4. 如果特征值属性的 Extended Properties 位未设置，则将 propertiesObj.reliableWrite 和 propertiesObj.writableAuxiliaries 初始化为 false。否则，运行以下步骤：

   1. 发现（Discover） Characteristic Extended Properties 描述符， 针对 characteristic 并读取其值到 extendedProperties。 错误按 § 6.7 错误处理 中所述进行处理。

      Characteristic Extended Properties 尚不明确扩展属性对于某个特定 Characteristic 是否不可变。 如果不可变，UA 应被允许对其进行缓存。

   2. 如果上一步返回了错误，则返回该错误。

   3. 从 extendedProperties 的 Reliable Write 位初始化 propertiesObj.reliableWrite。

   4. 从 extendedProperties 的 Writable Auxiliaries 位初始化 propertiesObj.writableAuxiliaries。

5. 返回 propertiesObj。

1. 令 promise 为一个新的 promise。

2. 并行运行以下步骤：

   1. 令 result 为 BluetoothRemoteGATTDescriptor 的新实例，其 [[representedDescriptor]] 槽位初始化为 descriptor。

   2. 用表示 descriptor 所在 Characteristic 的 BluetoothRemoteGATTCharacteristic 实例初始化 result.characteristic。

   3. 用 descriptor 的 UUID 初始化 result.uuid。

   4. 将 result.value 初始化为 null。 如果可用，UA 可以将 result.value 初始化为一个新的 DataView，其封装了一个新的 ArrayBuffer，包含最近一次从 descriptor 读取到的值。

   5. 在给定 this 的相关全局对象的前提下，在 Bluetooth 任务源上排队一个全局任务，以解析 promise，其值为 result。

3. 返回 promise。

1. 令 global 为this 的相关全局对象。

2. 令 gatt 为this.characteristic.service.device.gatt。

3. 如果this.uuid 被列入读取阻止列表，则返回一个被拒绝的 promise，错误为“SecurityError” 的 DOMException。

4. 如果 gatt.connected 为 false，则返回一个被拒绝的 promise，错误为“NetworkError” 的 DOMException。

5. 令 descriptor 为this.[[representedDescriptor]]。

6. 如果 descriptor 为 null，则返回一个被拒绝的 promise，错误为“InvalidStateError” 的 DOMException。

7. 返回一个围绕新 promise promise 的 gatt-连接检查包装器，并并行运行以下步骤：

   1. 如果 global 的navigable 的 top-level traversable 的 模拟蓝牙适配器 非空，则运行以下步骤：

      1. 如果this.[[automatedDescriptorReadResponse]] 不为 "not-expected"， 则在给定 global 的 全局任务队列中，基于 Bluetooth 任务源 拒绝 promise，错误为“InvalidStateError” 的 DOMException，并中止这些步骤。

      2. 触发一个模拟的描述符事件，传入 global 的 navigable、this.device、descriptor 和 read。

      3. 将this.[[automatedDescriptorReadResponse]] 设为 "expected"， 并等待其改变。

      4. 令 response 为this.[[automatedDescriptorReadResponse]]。

      5. 将this.[[automatedDescriptorReadResponse]] 设为 "not-expected"。

      6. 如果 response 不为 0，则执行以下子步骤：

         1. 在给定 global 的 全局任务队列中，基于 Bluetooth 任务源 拒绝 promise，错误为“NetworkError” 的 DOMException，并中止这些步骤。

      7. 否则，令 buffer 为一个新的 ArrayBuffer，其中包含 this.[[automatedDescriptorReadResponseData]]。

   2. 否则，运行以下步骤：

      1. 如果 UA 当前正在使用蓝牙系统，它可以在给定 global 的 全局任务队列中，基于 Bluetooth 任务源 拒绝 promise，错误为“NetworkError” 的 DOMException，并中止这些步骤。

         实现可能能够避免该 NetworkError， 但目前站点需要串行化使用该 API，和/或为用户提供重试失败操作的方法。[Issue #188]

      2. 使用 Read Characteristic Descriptors 或 Read Long Characteristic Descriptors 子流程获取 descriptor 的值，并令 buffer 为一个新的 ArrayBuffer，其中保存所取回的值。错误按 § 6.7 错误处理进行处理。

   3. 在给定 global 的 Bluetooth 任务源上排队一个全局任务以执行以下步骤：

      1. 如果 promise 不在 gatt.[[activeAlgorithms]] 中，则拒绝 promise，错误为“NetworkError” 的 DOMException，并中止这些步骤。

      2. 如果上述子流程返回错误，则拒绝 promise 并附带该错误，中止这些步骤。

      3. 将用 buffer 创建的新的 DataView 赋给 this.value。

      4. 解析 promise，其值为 this.value。

1. 令 global 为this 的相关全局对象。

2. 令 gatt 为this.characteristic.service.device.gatt。

3. 如果this.uuid 被列入写入阻止列表，则返回一个被拒绝的 promise，错误为“SecurityError” 的 DOMException。

4. 令 bytes 为由 value 持有字节的拷贝。

5. 如果 bytes 长度超过 512 字节（参见Long Attribute Values 中属性的最大长度），则返回一个被拒绝的 promise，错误为“InvalidModificationError” 的 DOMException。

6. 如果 gatt.connected 为 false，则返回一个被拒绝的 promise，错误为“NetworkError” 的 DOMException。

7. 令 descriptor 为this.[[representedDescriptor]]。

8. 如果 descriptor 为 null，则返回一个被拒绝的 promise，错误为“InvalidStateError” 的 DOMException。

9. 返回一个围绕新 promise promise 的 gatt-连接检查包装器，并并行运行以下步骤。

   1. 如果 global 的navigable 的 top-level traversable 的 模拟蓝牙适配器 非空，则运行以下步骤：

      1. 如果this.[[automatedDescriptorWriteResponse]] 不为 "not-expected"， 则在给定 global 的 全局任务队列中，基于 Bluetooth 任务源 拒绝 promise，错误为“InvalidStateError” 的 DOMException，并中止这些步骤。

      2. 触发一个模拟的描述符事件，传入 global 的 navigable、this.device、descriptor、write 和 bytes。

      3. 将this.[[automatedDescriptorWriteResponse]] 设为 "expected"， 并等待其改变。

      4. 令 response 为this.[[automatedDescriptorWriteResponse]]。

      5. 将this.[[automatedDescriptorWriteResponse]] 设为 "not-expected"。

      6. 如果 response 不为 0，则执行以下子步骤：

         1. 在给定 global 的 全局任务队列中，基于 Bluetooth 任务源 拒绝 promise，错误为“NetworkError” 的 DOMException，并中止这些步骤。

   2. 否则，运行以下步骤：

      1. 如果 UA 当前正在使用蓝牙系统，它可以在给定 global 的 全局任务队列中，基于 Bluetooth 任务源 拒绝 promise，错误为“NetworkError” 的 DOMException，并中止这些步骤。

         实现可能能够避免该 NetworkError， 但目前站点需要串行化使用该 API，和/或为用户提供重试失败操作的方法。[Issue #188]

      2. 使用 Write Characteristic Descriptors 或 Write Long Characteristic Descriptors 子流程将 bytes 写入 descriptor。错误按 § 6.7 错误处理进行处理。

   3. 在给定 global 的 Bluetooth 任务源上排队一个全局任务以执行以下步骤：

      1. 如果 promise 不在 gatt.[[activeAlgorithms]] 中，则拒绝 promise，错误为“NetworkError” 的 DOMException，并中止这些步骤。

      2. 如果上述子流程返回错误，则拒绝 promise 并附带该错误，中止这些步骤。

      3. 将this.value 设为一个新的 DataView，其封装了一个新的 ArrayBuffer，其中包含 bytes。

      4. 解析 promise，其值为 undefined。

1. 如果 deviceObj.[[representedDevice]] 与 device 不是同一设备，则中止这些步骤。

2. 如果 !deviceObj.gatt.connected， 则中止这些步骤。

3. 清理已断开连接的设备 deviceObj。

1. 将 deviceObj.gatt.connected 设为 false。

2. 清空 deviceObj.gatt.[[activeAlgorithms]]。

3. 将 deviceObj.gatt.[[automatedGATTConnectionResponse]] 设为 "not-expected"。

4. 令 context 为 deviceObj.[[context]]。

5. 从 context.[[attributeInstanceMap]] 中移除所有键位于 deviceObj.[[representedDevice]] 范围内的条目。

6. 对于 deviceObj 的 realm 中的每个 BluetoothRemoteGATTService service，将 service.[[representedService]] 设为 null。

7. 对于 deviceObj 的 realm 中的每个 BluetoothRemoteGATTCharacteristic characteristic，执行以下子步骤：

   1. 令 notificationContexts 为 characteristic.[[representedCharacteristic]] 的活动通知上下文集合。

   2. 从 notificationContexts 中移除 context。

   3. 如果 notificationContexts 变为空，并且仍然存在到 deviceObj.[[representedDevice]] 的 ATT 承载， 且 characteristic 具有 客户端特征值配置（Client Characteristic Configuration） 描述符，则 UA 应使用任意 特征值描述符流程清除 characteristic 的 客户端特征值配置 描述符中的 Notification 与 Indication 位。

   4. 将 characteristic.[[representedCharacteristic]] 设为 null。

8. 对于 deviceObj 的 realm 中的每个 BluetoothRemoteGATTDescriptor descriptor，将 descriptor.[[representedDescriptor]] 设为 null。

9. 触发一个事件，名称为 gattserverdisconnected， 其 bubbles 属性初始化为 true，在 deviceObj 上触发。

   注意：该事件不会在 BluetoothRemoteGATTServer 上触发。

1. 对于特征值的活动通知上下文集合中的每个 bluetoothGlobal，在给定 bluetoothGlobal 的相关全局对象的前提下，基于 Bluetooth 任务源 排队一个全局任务以执行以下子步骤：

   1. 令 characteristicObject 为以 bluetoothGlobal 为根的 Bluetooth 树中，表示该 Characteristic 的 BluetoothRemoteGATTCharacteristic。

   2. 如果 characteristicObject .service.device.gatt.connected 为 false，则中止这些子步骤。

   3. 将 characteristicObject.value 设为一个新的 DataView， 其封装一个新的 ArrayBuffer， 其中保存该Characteristic 的新值。

   4. 触发一个事件，名称为 characteristicvaluechanged， 其 bubbles 属性初始化为 true，在 characteristicObject 上触发。