Web Bluetooth

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 尚未广播服务数据，其 UUID 的 128 位形式为 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"，则返回 一个被拒绝的 promise，其拒绝原因为一个 SecurityError。

3. 令 promise 为一个新的 promise。

4. 并行运行以下步骤：

   1. 令 devices 为一个新的空 Array。

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

   3. 在给定 global 的蓝牙任务源上排入一个全局任务，以使用 devices 兑现 promise。

   注：devices 中的 BluetoothDevice 可能不在蓝牙无线电的 范围内。对于 devices 中的给定 device， 可使用 watchAdvertisements() 方法观察 device 何时处于范围内并广播广播数据包。当 advertisementreceived 事件 event 在 device 上触发时，它可能 表明该设备已经足够接近，可以通过调用 event.device.gatt.connect() 建立连接。

5. 返回 promise。

1. 如果 options.exclusionFilters 存在 ，并且 options.filters 不存在， 则返回 一个被拒绝的 promise，其拒绝原因为一个 TypeError。

2. 如果 options.filters 存在，并且 options.acceptAllDevices 为 true， 或者如果 options.filters 不存在 并且 options.acceptAllDevices 为 false，则返回 一个被拒绝的 promise，其拒绝原因为一个 TypeError。

   注：这会强制要求 filters 或 acceptAllDevices:true 恰好存在其中一个。

3. 令 promise 为一个新的 promise。

4. 并行运行以下步骤：

   1. 请求蓝牙设备，如果 options.acceptAllDevices 为 false，则传入 options.filters， 否则传入 null；如果 options.exclusionFilters 存在则传入它，否则传入 null；并传入 options.optionalServices 和 options.optionalManufacturerData， 并令 devices 为结果。

   2. 在蓝牙任务源上排入一个全局任务，给定 this 的 相关全局对象，以运行以下 步骤：

      1. 如果上一步抛出异常，则使用该 异常拒绝 promise 并中止这些步骤。

      2. 如果 devices 是空序列，则以 NotFoundError 拒绝 promise 并中止这些步骤。

      3. 使用 devices[0] 兑现 promise。

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，则对于 exclusionFilters 中的每个 exclusionFilter，执行以下步骤：

      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 的权限状态。

   注：在非安全上下文中，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 的可导航对象。

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

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

1. 给定 navigable、promptId 和 scanResult， 触发提示更新事件。

2. 即使 scanResult 为空， 也提示用户选择 scanResult 中与 descriptor 关联的设备之一，并令 device 为结果。

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

   注：UA 应向用户显示每个设备的人类可读名称。 如果该名称不可用，例如因为 UA 的蓝牙 系统不支持启用隐私的扫描，则 UA 应允许用户 表示兴趣，然后执行禁用隐私的扫描以检索 名称。

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

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

   注：选择 device 很可能表明用户 希望该设备至少在当前设置 对象的 "bluetooth" 额外权限数据的 allowedDevices 列表中出现，使其 mayUseGATT 字段为 true，使 requiredServiceUUIDs 和 optionalServiceUUIDs 并集中的所有服务都出现在其 allowedServices 列表中，此外 还保留已经存在的任何服务，并使 optionalManufacturerData 中的制造商代码出现在其 allowedManufacturerData 列表中。

5. 如果 device 为“denied”， 则返回 [] 并中止这些步骤。

6. UA 可以使用 device 内的所有服务填充蓝牙缓存。 忽略此步骤产生的任何错误。

7. 在 this 内获取表示 device 的 BluetoothDevice， 传播任何异常，并令 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 并中止这些步骤。

      注：248 是蓝牙 设备名称中 UTF-8 码元的最大数量。

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

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

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

      注：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 的长度为零，则抛出 TypeError 并中止 这些步骤。

2. 如果 filter.mask 存在，则令 mask 为 filter.mask 所持字节的副本。 否则，令 mask 为一个由 0xFF 字节组成、长度与 dataPrefix 相同的序列。

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 的可导航对象的 顶级可遍历对象。

4. 令 simulatedBluetoothDevices 为一个空列表。

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

   支持 异步设备发现。

6. 如果 UA 支持 LE 传输，则执行通用 发现 过程，但 UA 可以包含未设置 可发现 模式标志的设备，并将发现的蓝牙 设备添加到 nearbyDevices。UA 应启用隐私 功能。

   被动 扫描和隐私功能都能避免 泄露唯一且不可变的设备 ID。我们应当要求 UA 使用 两者之一，但似乎没有任何操作系统 API 暴露其中任一种。蓝牙还 使得被动扫描难以使用，因为它并不要求 中心设备支持 观察过程。

7. 如果 UA 支持 BR/EDR 传输，则执行设备发现 过程，并将发现的蓝牙设备添加到 nearbyDevices。

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

8. 令 result 为一个初始为空的蓝牙设备集合。

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

   1. 如果 device 的支持的物理传输包含 LE 且其蓝牙设备名称是部分名称或不存在， 则 UA 应执行名称发现过程以获取 完整名称。

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

      注：对于 BR/EDR 设备，在扩展查询响应中无法区分 GATT 服务和非 GATT 服务。如果站点 使用非 GATT 服务的 UUID 进行过滤，则用户可能能够 为 requestDevice 的结果选择一个设备，而此 API 没有提供与该设备交互的方法。

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

      注：连接到每个附近设备以发现服务会消耗 电力，并可能减慢蓝牙无线电的其他使用。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 的蓝牙任务源上排入一个全局任务，以使用 false 兑现 promise， 并中止这些步骤。

3. 如果用户已将 UA 配置为让此函数针对当前源返回 特定答案，则排入一个 任务，以使用所配置的答案兑现 promise，并中止 这些步骤。

   注：如果用户已阻止 Web Bluetooth 权限，UA 可以使用 false 兑现 promise。

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

5. 如果 simulatedBluetoothAdapter 不为空，

   1. 如果 simulatedBluetoothAdapter 的适配器状态为 "absent"，则在给定 global 的蓝牙任务源上排入一个全局任务，以使用 false 兑现 promise。

   2. 如果 simulatedBluetoothAdapter 的LE 支持状态为 false，则在给定 global 的蓝牙任务源上排入一个全局任务，以使用 false 兑现 promise。

   3. 否则，在给定 global 的蓝牙任务源上排入一个全局任务，以使用 true 兑现 promise。

   4. 中止这些步骤。

6. 如果 UA 正在具有蓝牙无线电的系统上运行，则无论蓝牙 无线电是否开启，都在给定 global 的蓝牙任务源上排入一个全局任务，以使用 true 兑现 promise。

7. 否则，在给定 global 的蓝牙任务源上排入一个全局任务，以使用 false 兑现 promise。

   注：promise 会被并行兑现，以允许 UA 调用 其他系统来确定蓝牙是否可用。

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

2. 在 storage.allowedDevices 中查找 allowedDevice，其 allowedDevice.[[device]] 与 device 是同一设备。如果不存在这样的对象，则抛出 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. 如果 "bluetooth" 对 this 的相关 设置对象的额外权限数据在其 allowedDevices 列表中具有一个 AllowedBluetoothDevice 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. 以 AbortError 拒绝 promise。

3. 如果 this.[[watchAdvertisementsState]] 为：

   'not-watching'

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

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

      1. 确保 UA 正在扫描此设备的 广播。UA 不应过滤掉同一设备的“重复” 广播。

      2. 如果 UA 无法启用扫描，则在给定 global 的蓝牙任务源上排入一个全局任务以执行 以下步骤，并中止这些步骤：

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

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

            UA 不支持扫描广播

            NotSupportedError

            蓝牙已关闭

            InvalidStateError

            其他原因

            UnknownError

      3. 在给定 global 的蓝牙任务源上排入一个全局任务以执行以下步骤，但当 this.[[watchAdvertisementsState]] 变为 not-watching 时中止：

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

         2. 将 this.watchingAdvertisements 设置为 true。

         3. 以 undefined 兑现 promise。

   'pending-watch'

   1. 以 InvalidStateError 拒绝 promise。

   'watching'

   1. 以 undefined 兑现 promise。

4. 如果已中止，则以 AbortError 拒绝 promise。

注：扫描会消耗电力，因此网站应避免 不必要地监听广播， 并应使用其 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. 尝试使缓存中所有匹配条目变为已知存在或 已知不存在，可以使用[BLUETOOTH42]所规定能够返回足够 信息的任意GATT 过程序列。按照 § 6.7 错误处理中的说明处理错误。

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

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

2. 使用与描述 匹配的条目填充蓝牙缓存。

3. 如果上一步返回错误，则在给定 global 的 蓝牙任务源上排入一个全局任务，以使用该 错误拒绝 promise，并中止这些步骤。

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

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

6. 令 result 为一个新序列。

7. 对于 entries 中的每个 entry：

   1. 如果 entry 没有关联的 Promise<BluetoothGATT*> 实例位于 context.[[attributeInstanceMap]] 中， 创建一个 BluetoothRemoteGATTService，表示 entry， 创建一个 BluetoothRemoteGATTCharacteristic 表示 entry，或创建一个 BluetoothRemoteGATTDescriptor，表示 entry， 具体取决于 entry 是 Service、Characteristic 还是 Descriptor，并添加从 entry 到所得 Promise 的映射，位于 context.[[attributeInstanceMap]] 中。

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

8. 排入一个全局任务 到 蓝牙任务源 （给定 global），以 兑现 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. 根据 attribute 的类型，令 deviceObj 为：

   BluetoothDevice

   attribute

   BluetoothRemoteGATTService

   attribute.device

   BluetoothRemoteGATTCharacteristic

   attribute.service.device

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

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

   注：当服务或 特征从设备中移除或因断开连接而失效，随后再次使用其对象时，就会发生这种情况。

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

   • 位于 Represented(attribute) 内，

   • 具有由 child type 描述的类型，

   • 具有未被阻止的 UUID，

   • 如果存在 uuid，则具有 UUID uuid，

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

   • 如果设置了 single 标志，则是其中第一个。

   令 promise 为结果。

7. 兑现后，对于 promise 以 result 兑现的情况，运行 以下步骤：

   • 如果 result 为空，则抛出 NotFoundError。

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

   • 否则，返回 result。

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

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

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

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

4. 令 promise 为一个新的 promise。

5. 如果 this.connected 为 true， 则使用 this 兑现 promise 并返回 promise。

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

7. 并行运行以下步骤：

   1. 如果 global 的可导航对象的 顶级可遍历对象的模拟蓝牙适配器 不为空，则运行以下步骤：

      1. 给定 global 的 可导航对象和 this.device，触发一个 GATT 连接尝试事件。

      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 的蓝牙任务源上排入一个全局任务，以使用“NetworkError” DOMException 拒绝 promise 并中止这些步骤。

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

      1. 如果 this.device.[[representedDevice]] 没有ATT 承载，则执行以下子步骤：

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

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

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

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

         4. 使用交换 MTU过程协商 支持的最大 MTU。忽略此步骤产生的任何错误。

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

            注：通常我们 更希望让网站控制 是否以及何时进行绑定，但 Core Bluetooth 平台 API 并未提供让 UA 实现这种控制项的方法。 已绑定比未绑定更安全，因此本 规范允许 UA 在可行的平台上伺机创建绑定。 这可能会导致在创建连接时出现用户可见的 配对对话框，而不是在访问受限特征时出现。

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

      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. 使用 this 兑现 promise。

8. 返回 promise。

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

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

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

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

5. 对连接进行垃圾回收，该连接属于 device。

1. 如果未使用此 API 的系统（无论位于 UA 内部还是外部） 正在使用 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 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]] 中，则返回 一个以 SecurityError 拒绝的 promise 并中止这些步骤。

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]] 中，则返回 一个以 SecurityError 拒绝的 promise 并中止这些步骤。

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. 获取表示 service 所在设备的 BluetoothDevice，并令 device 为结果。

   3. 如果上一步抛出错误，则在给定 global 的蓝牙任务源上排入一个全局任务，以使用 该错误拒绝 promise 并中止这些步骤。

   4. 使用 device 初始化 result.device。

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

   6. 如果 service 是主服务，则将 result.isPrimary 初始化为 true。否则， 将 result.isPrimary 初始化为 false。

   7. 在给定 global 的蓝牙任务源上排入一个全局任务， 以使用 result 兑现 promise。

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 所在服务的 BluetoothRemoteGATTService 实例初始化 result.service<。

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

   4. 创建 一个 BluetoothCharacteristicProperties 实例，该实例来自 特征 characteristic，并令 properties 为 结果。

   5. 如果上一步返回错误，则在给定 global 的蓝牙任务源上排入一个全局任务，以使用 该错误拒绝 promise 并中止这些步骤。

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

   7. 将 result.value 初始化为 null。如果 characteristic 最近读取的值可用，UA 可以将 result.value 初始化为一个新的 DataView，该对象包装一个包含 characteristic 最近读取值的新的 ArrayBuffer。

   8. 在给定 global 的蓝牙任务源上排入一个全局任务， 以使用 result 兑现 promise。

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 被阻止读取，则返回一个以“SecurityError” DOMException 拒绝的 promise 并中止这些步骤。

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

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

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

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

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

   2. 如果 global 的可导航对象的 顶级可遍历对象的模拟蓝牙适配器 不为空，则运行以下步骤：

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

      2. 给定 global 的 可导航对象、this.device、 characteristic 和 read，触发一个模拟 特征事件。

      3. 将 this.[[automatedCharacteristicReadResponse]] 设置为 "expected"， 并等待它发生变化。

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

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

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

         1. 在给定 global 的蓝牙任务源上排入一个全局任务，以使用“NetworkError” DOMException 拒绝 promise 并中止这些步骤。

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

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

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

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

      2. 使用特征值读取 过程中的任意子过程组合来检索 characteristic 的值，并令 buffer 为一个保存所检索值的新的 ArrayBuffer。 按照§ 6.7 错误 处理中的说明处理错误。

   4. 在给定 global 的蓝牙任务源上排入一个全局任务， 以执行以下步骤：

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

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

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

      4. 在 this 上触发一个名为“characteristicvaluechanged”的事件， 并将其 bubbles 属性初始化为 true。

      5. 使用 this.value 兑现 promise。

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

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

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

4. 令 bytes 为 value 所持字节的副本。

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

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

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

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

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

   1. 断言：response 是 "required"、"never" 或 "optional" 之一。

   2. 如果 global 的可导航对象的 顶级可遍历对象的模拟蓝牙适配器 不为空，则运行以下步骤：

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

      2. 给定 global 的 可导航对象、this.device、 characteristic、write 和 bytes，触发一个模拟 特征事件。

      3. 将 this.[[automatedCharacteristicWriteResponse]] 设置为 "expected"， 并等待它发生变化。

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

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

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

         1. 在给定 global 的蓝牙任务源上排入一个全局任务，以使用“NetworkError” DOMException 拒绝 promise 并中止这些步骤。

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

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

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

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

         如果 response 为 "required"

         使用写入特征值 过程。

         如果 response 为 "never"

         使用无响应写入 过程。

         其他情况

         使用特征值写入 过程中的任意子过程组合。

         按照§ 6.7 错误处理中的说明处理错误。

   4. 使用蓝牙任务源在 global 上排入一个全局任务，以执行 以下步骤：

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

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

      3. 将 this.value 设置为一个 新的 DataView， 它包装一个包含 bytes 的新的 ArrayBuffer。

      4. 使用 undefined 兑现 promise。

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 被阻止读取，则返回一个以“SecurityError” DOMException 拒绝的 promise。

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

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

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

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

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

   2. 如果 characteristic 的活动通知上下文集合 包含 navigator.bluetooth， 则在给定 global 的蓝牙任务源上排入一个全局任务， 以使用 this 兑现 promise 并中止 这些步骤。

   3. 如果 global 的可导航对象的 顶级可遍历对象的模拟蓝牙适配器 不为空，则运行以下步骤：

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

      2. 给定 global 的 可导航对象、this.device、 characteristic 和 subscribe-to-notifications，触发一个模拟 特征事件。

      3. 将 this.[[automatedCharacteristicSubscribeToNotificationsResponse]] 设置为 "expected"， 并等待它发生变化。

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

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

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

         1. 在给定 global 的蓝牙任务源上排入一个全局任务，以使用“NetworkError” DOMException 拒绝 promise 并中止这些步骤。

      7. 否则，令 success 为 true。

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

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

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

      2. 如果该特征具有客户端特征 配置 描述符，则使用任意特征描述符 过程，以 确保 characteristic 的客户端特征 配置 描述符中的 Notification 或 Indication 位之一已设置，并符合 characteristic 的 属性约束。UA 应避免 同时设置两个位，并且如果两个位均已 设置，则必须对值变化事件去重。按照§ 6.7 错误 处理中的说明处理错误。

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

      3. 如果这些过程成功，则令 success 为 true。

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

   6. 在给定 global 的蓝牙任务源上排入一个全局任务， 以执行以下步骤：

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

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

      3. 使用 this 兑现 promise。

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

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

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

   1. 如果 global 的可导航对象的 顶级可遍历对象的模拟蓝牙适配器 不为空，则运行以下步骤：

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

      2. 给定 global 的 可导航对象、this.device、 characteristic 和 unsubscribe-from-notifications，触发一个模拟 特征事件。

      3. 将 this.[[automatedCharacteristicUnsubscribeFromNotificationsResponse]] 设置为 "expected"， 并等待它发生变化。

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

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

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

         1. 在给定 global 的蓝牙任务源上排入一个全局任务，以使用“NetworkError” DOMException 拒绝 promise 并中止这些步骤。。

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

      1. 如果 characteristic 的活动通知上下文 集合变为 空，并且该特征具有客户端特征 配置描述符，则 UA 应使用任意特征 描述符过程来清除 characteristic 的客户端 特征配置描述符中的 Notification 和 Indication 位。

4. 在给定 this 的 相关全局对象的蓝牙任务源上排入一个全局任务，以使用 this 兑现 promise。

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

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

3. 根据 properties 中对应的 位初始化 propertiesObj 的属性：

   属性	位
   broadcast	广播
   read	读取
   writeWithoutResponse	无响应写入
   write	写入
   notify	通知
   indicate	指示
   authenticatedSignedWrites	已认证签名写入

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

   1. 发现 characteristic 的特征扩展 属性描述符，并读取其 值到 extendedProperties 中。 按照§ 6.7 错误处理中的说明处理错误。

      特征扩展 属性并未明确说明 对于给定特征，扩展属性是否不可变。 如果它们不可变，则应允许 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 所在特征的 BluetoothRemoteGATTCharacteristic 实例初始化 result.characteristic。

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

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

   5. 在给定 this 的相关全局对象的蓝牙任务源上排入一个全局任务，以使用 result 兑现 promise。

3. 返回 promise。

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

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

3. 如果 this.uuid 被阻止读取，则返回一个以“SecurityError” DOMException 拒绝的 promise。

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

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

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

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

   1. 如果 global 的可导航对象的 顶级可遍历对象的模拟蓝牙适配器 不为空，则运行以下步骤：

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

      2. 给定 global 的 可导航对象、this.device、 descriptor 和 read，触发一个模拟 描述符事件。

      3. 将 this.[[automatedDescriptorReadResponse]] 设置为 "expected"， 并等待它发生变化。

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

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

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

         1. 在给定 global 的蓝牙任务源上排入一个全局任务，以使用“NetworkError” DOMException 拒绝 promise 并中止这些步骤。

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

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

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

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

      2. 使用读取特征 描述符或读取长特征 描述符子过程来检索 descriptor 的值，并令 buffer 为一个新的 ArrayBuffer， 其中保存 检索到的值。按照 § 6.7 错误处理中的说明处理错误。

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

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

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

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

      4. 使用 this.value 兑现 promise。

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

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

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

4. 令 bytes 为 value 所持字节的副本。

5. 如果 bytes 的长度超过 512 字节（根据长属性值，这是属性 值的最大长度），则返回一个以 “InvalidModificationError” DOMException 拒绝的 promise。

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

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

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

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

   1. 如果 global 的可导航对象的 顶级可遍历对象的模拟蓝牙适配器 不为空，则运行以下步骤：

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

      2. 给定 global 的 可导航对象、this.device、 descriptor、write 和 bytes，触发一个模拟 描述符事件。

      3. 将 this.[[automatedDescriptorWriteResponse]] 设置为 "expected"， 并等待它发生变化。

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

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

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

         1. 在给定 global 的蓝牙任务源上排入一个全局任务，以使用“NetworkError” DOMException 拒绝 promise 并中止这些步骤。

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

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

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

      2. 使用写入特征 描述符或写入长特征 描述符子过程，将 bytes 写入 descriptor。按照 § 6.7 错误处理中的说明处理错误。

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

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

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

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

      4. 使用 undefined 兑现 promise。