RxBluetoothKit

https://polidea.github.io/RxBluetoothKit/
Admin
RxBluetoothKit is a Bluetooth library that provides a pleasant ReactiveX API for interacting with...
Tokens:32,373
Snippets:373
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Initialize and Start Advertising

Source: https://polidea.github.io/RxBluetoothKit/Classes/PeripheralManager.html

Chain state observation with service addition and advertising start. Ensure Bluetooth is powered on before executing these operations.

```Swift
let disposable = centralManager.observeStateWithInitialValue()
    .filter { $0 == .poweredOn }
    .take(1)
    .flatMap { centralManager.add(myService) }
    .flatMap { centralManager.startAdvertising(myAdvertisementData) }
```

```Swift
disposable.dispose()
```

--------------------------------

### Start Peripheral Advertising

Source: https://polidea.github.io/RxBluetoothKit/Classes.html

Configures and starts advertising services using PeripheralManager.

```Swift
let disposable = centralManager.observeStateWithInitialValue()
    .filter { $0 == .poweredOn }
    .take(1)
    .flatMap { centralManager.add(myService) }
    .flatMap { centralManager.startAdvertising(myAdvertisementData) }
```

--------------------------------

### StartAdvertisingResult Case: started

Source: https://polidea.github.io/RxBluetoothKit/Enums/StartAdvertisingResult.html

Indicates that advertising was successfully initiated with the provided data.

```Swift
case started
```

--------------------------------

### Install RxBluetoothKit with CocoaPods

Source: https://polidea.github.io/RxBluetoothKit/index.html

Use this command to integrate RxBluetoothKit into your Xcode project using CocoaPods. Ensure CocoaPods is installed and configured.

```bash
pod 'RxBluetoothKit'

```

--------------------------------

### Start Advertising Method

Source: https://polidea.github.io/RxBluetoothKit/Classes/PeripheralManager.html

Initiates peripheral advertising. Note that Core Bluetooth limits to one ongoing advertising session at a time.

```Swift
public func startAdvertising(_ advertisementData: [String : Any]?) -> Observable<StartAdvertisingResult>
```

--------------------------------

### PeripheralManager Advertising

Source: https://polidea.github.io/RxBluetoothKit/Classes/PeripheralManager.html

Starts peripheral advertising. Advertising is automatically stopped upon subscription disposal. Errors can occur if advertising is already in progress or fails to start.

```APIDOC
## PeripheralManager Advertising

### Description
Starts peripheral advertising on subscription. It creates an infinite observable that emits a single `StartAdvertisingResult` value just after advertising succeeds. Advertising is automatically stopped upon subscription disposal.

There can only be one ongoing advertising process due to CoreBluetooth limitations. Calling this method when already advertising will result in an `advertisingInProgress` error.

### Method
`startAdvertising(_:)`

### Parameters
- **advertisementData** ([String : Any]?) - Optional - A dictionary containing advertisement data. Nil value accepts all peripherals.

### Return Value
An `Observable<StartAdvertisingResult>` that emits when advertisement starts.

### Errors
- `BluetoothError.advertisingInProgress`
- `BluetoothError.advertisingStartFailed`
- `BluetoothError.destroyed`
- `BluetoothError.bluetoothUnsupported`
- `BluetoothError.bluetoothUnauthorized`
- `BluetoothError.bluetoothPoweredOff`
- `BluetoothError.bluetoothInUnknownState`
- `BluetoothError.bluetoothResetting
```

--------------------------------

### Install RxBluetoothKit with Carthage

Source: https://polidea.github.io/RxBluetoothKit/index.html

Integrate RxBluetoothKit using Carthage by specifying it in your Cartfile and running the update command. Then, drag the framework into your Xcode project.

```bash
github "Polidea/RxBluetoothKit"

```

--------------------------------

### GET /scanForPeripherals

Source: https://polidea.github.io/RxBluetoothKit/Classes/CentralManager.html

Scans for peripherals that match the provided service UUIDs.

```APIDOC
## scanForPeripherals(withServices:options:)

### Description
Scans for peripherals after subscription to the returned observable. If serviceUUIDs is nil, all peripherals are accepted.

### Parameters
#### Query Parameters
- **serviceUUIDs** ([CBUUID]?) - Optional - Services of peripherals to search for.
- **options** ([String: Any]?) - Optional - Optional scanning options.

### Response
#### Success Response (200)
- **Observable<ScannedPeripheral>** - Infinite stream of scanned peripherals.
```

--------------------------------

### StartAdvertisingResult Case: attachedToExternalAdvertising

Source: https://polidea.github.io/RxBluetoothKit/Enums/StartAdvertisingResult.html

Indicates the manager attached to an existing advertising session started outside the library. Note that the actual advertisement data may differ from the provided parameters.

```Swift
case attachedToExternalAdvertising(RestoredAdvertisementData?)
```

--------------------------------

### Scan for Peripherals with Options

Source: https://polidea.github.io/RxBluetoothKit/Classes/CentralManager.html

Scans for peripherals. You can filter by service UUIDs or use nil to discover all peripherals. Options can be provided for further customization. Scanning is an infinite stream that must be stopped manually, for example, by using `.timeout` or `.take`.

```swift
centralManager.scanForPeripherals(withServices: nil)
    .timeout(3.0, timeoutScheduler)
    .take(2)
```

--------------------------------

### GET /observeState

Source: https://polidea.github.io/RxBluetoothKit/Classes/CentralManager.html

Observes the current Bluetooth state of the manager.

```APIDOC
## observeState()

### Description
Returns an observable that emits the current BluetoothState.

### Response
#### Success Response (200)
- **Observable<BluetoothState>** - Stream of Bluetooth state changes.
```

--------------------------------

### publishL2CAPChannel

Source: https://polidea.github.io/RxBluetoothKit/Classes/PeripheralManager.html

Starts publishing an L2CAP channel on a subscription. The channel is automatically unpublished when the subscription is disposed.

```APIDOC
## publishL2CAPChannel(withEncryption:)

### Description
Starts publishing an L2CAP channel. It returns an infinite observable that emits a CBL2CAPPSM value once the channel is published.

### Parameters
#### Request Body
- **encryptionRequired** (Bool) - Required - Publishing channel with or without encryption.

### Response
#### Success Response (200)
- **CBL2CAPPSM** (Object) - Emits the L2CAP PSM value upon successful publication.

### Errors
- BluetoothError.publishingL2CAPChannelFailed
- BluetoothError.destroyed
- BluetoothError.bluetoothUnsupported
- BluetoothError.bluetoothUnauthorized
- BluetoothError.bluetoothPoweredOff
- BluetoothError.bluetoothInUnknownState
- BluetoothError.bluetoothResetting
```

--------------------------------

### BluetoothError Advertising Start Failed Case

Source: https://polidea.github.io/RxBluetoothKit/Enums/BluetoothError.html

Represents a failure when starting Bluetooth advertising. It includes the underlying error that caused the failure.

```swift
case advertisingStartFailed(Error)
```

--------------------------------

### Publish L2CAP Channel

Source: https://polidea.github.io/RxBluetoothKit/Classes/PeripheralManager.html

Starts publishing an L2CAP channel on a subscription. The channel is automatically unpublished when the subscription is disposed.

```Swift
@available(iOS 11, tvOS 11, watchOS 4, *)
public func publishL2CAPChannel(withEncryption encryptionRequired: Bool) -> Observable<CBL2CAPPSM>
```

--------------------------------

### Peripheral Name Property

Source: https://polidea.github.io/RxBluetoothKit/Classes/Peripheral.html

Gets the current name of the Peripheral instance, analogous to CBPeripheral's name.

```swift
public var name: String? { get }
```

--------------------------------

### Get Log Level

Source: https://polidea.github.io/RxBluetoothKit/Classes/RxBluetoothKitLog.html

Retrieves the currently active logging level.

```Swift
public static func getLogLevel() -> RxBluetoothKitLog.LogLevel
```

--------------------------------

### Get Log Level

Source: https://polidea.github.io/RxBluetoothKit/Protocols/Logger.html

Retrieves the currently configured logging severity level.

```Swift
func getLogLevel() -> RxBluetoothKitLog.LogLevel
```

--------------------------------

### Get Service by Identifier

Source: https://polidea.github.io/RxBluetoothKit/Classes/Peripheral.html

Use this function to retrieve a service with a specific identifier. It attempts to fetch from cache first, otherwise it performs a discovery. Can error if services discovery fails, peripheral disconnects, or Bluetooth is unavailable/unsupported.

```swift
public func service(with identifier: ServiceIdentifier) -> Single<Service>
```

--------------------------------

### Get Descriptor by Identifier

Source: https://polidea.github.io/RxBluetoothKit/Classes/Peripheral.html

Fetches a descriptor by its identifier, prioritizing cache. Errors may arise from descriptor discovery failure, peripheral disconnection, or Bluetooth operational problems.

```swift
public func descriptor(with identifier: DescriptorIdentifier) -> Single<Descriptor>
```

--------------------------------

### Initialize AdvertisementData

Source: https://polidea.github.io/RxBluetoothKit/Structs/AdvertisementData.html

Creates an instance using a CoreBluetooth advertisement dictionary.

```Swift
public init(advertisementData: [String : Any])
```

--------------------------------

### Scan, Connect, Discover, and Read Characteristic Value

Source: https://polidea.github.io/RxBluetoothKit/index.html

This snippet demonstrates a common workflow: scanning for peripherals, connecting, discovering services and characteristics, and reading a characteristic's value. It utilizes RxBluetoothKit's reactive extensions for a concise implementation.

```swift
manager.scanForPeripherals(withServices: [serviceId])
    .take(1)
    .flatMap { $0.peripheral.establishConnection() }
    .flatMap { $0.discoverServices([serviceId]) }
    .flatMap { Observable.from($0) }
    .flatMap { $0.discoverCharacteristics([characteristicId]) }
    .flatMap { Observable.from($0) }
    .flatMap { $0.readValue() }
    .subscribe(onNext: { print("Value: \($0.value)") })

```

--------------------------------

### Peripheral Connection Methods

Source: https://polidea.github.io/RxBluetoothKit/Classes/Peripheral.html

Methods for observing and establishing connections with a Bluetooth peripheral.

```APIDOC
## observeConnection()

### Description
Returns a continuous observable indicating if the peripheral is in a connected state. Emits a new value whenever the connection state changes.

### Method
GET

### Response
- **Observable<Bool>** - Emits true if connected, false otherwise.

## establishConnection(options:)

### Description
Establishes a connection with the peripheral.

### Method
POST

### Parameters
#### Request Body
- **options** ([String: Any]?) - Optional - Dictionary to customize the behavior of the connection.

### Response
- **Observable<Peripheral>** - Emits the connected Peripheral instance.
```

--------------------------------

### Get Log Level

Source: https://polidea.github.io/RxBluetoothKit/Classes/RxBluetoothKitLog.html

Retrieves the currently active logging level.

```APIDOC
## STATIC getLogLevel()

### Description
Returns the current log level set for the library.

### Response
- **Return Value** (RxBluetoothKitLog.LogLevel) - Currently set log level.
```

--------------------------------

### Observe write readiness in Swift

Source: https://polidea.github.io/RxBluetoothKit/Classes/Peripheral.html

Emits an element when the peripheral is ready to receive characteristic value updates after a failed write operation.

```Swift
public func observeWriteWithoutResponseReadiness() -> Observable<Void>
```

--------------------------------

### Observe Peripheral Manager Ready

Source: https://polidea.github.io/RxBluetoothKit/Classes/PeripheralManager.html

Continuously observes when the peripheral manager is ready to update subscribers. This is an infinite stream and may error if Bluetooth becomes unavailable or the manager is destroyed.

```swift
public func observeIsReadyToUpdateSubscribers() -> Observable<Void>
```

--------------------------------

### Get Current Bluetooth State

Source: https://polidea.github.io/RxBluetoothKit/Classes/CentralManager.html

Retrieves the current state of the Bluetooth adapter.

```swift
public var state: BluetoothState { get }
```

--------------------------------

### PeripheralManager Initialization

Source: https://polidea.github.io/RxBluetoothKit/Classes/PeripheralManager.html

Initializes a new PeripheralManager instance with support for Bluetooth state restoration.

```APIDOC
## init(queue:options:onWillRestorePeripheralManagerState:)

### Description
Creates a new PeripheralManager instance that supports state restoration. Use this to handle background restoration of Bluetooth state.

### Parameters
#### Request Body
- **queue** (DispatchQueue) - Optional - Queue on which bluetooth callbacks are received. Defaults to main thread.
- **options** ([String: AnyObject]) - Optional - Initialization options for the peripheral manager.
- **onWillRestorePeripheralManagerState** (Closure) - Optional - Closure called when state has been restored.
```

--------------------------------

### State Observation Methods

Source: https://polidea.github.io/RxBluetoothKit/Classes/PeripheralManager.html

Methods to monitor the current Bluetooth state.

```Swift
public var state: BluetoothState { get }
```

```Swift
public func observeState() -> Observable<BluetoothState>
```

```Swift
public func observeStateWithInitialValue() -> Observable<BluetoothState>
```

--------------------------------

### Characteristic Value Property

Source: https://polidea.github.io/RxBluetoothKit/Classes/Characteristic.html

Get the current value of the characteristic. Returns nil if no value is present.

```swift
public var value: Data? { get }
```

--------------------------------

### Compare Peripheral instances

Source: https://polidea.github.io/RxBluetoothKit/Functions.html

Compares two peripherals; they are considered equal if their identifiers match.

```Swift
public func == (lhs: Peripheral, rhs: Peripheral) -> Bool
```

--------------------------------

### Add Service Method

Source: https://polidea.github.io/RxBluetoothKit/Classes/PeripheralManager.html

Adds a service to the peripheral manager and waits for the delegate callback.

```Swift
public func add(_ service: CBMutableService) -> Single<CBService>
```

--------------------------------

### StartAdvertisingResult Enumeration

Source: https://polidea.github.io/RxBluetoothKit/Enums.html

Enum result returned by the PeripheralManager.startAdvertising method.

```APIDOC
## StartAdvertisingResult

### Description
Enum result that is returned as a result of PeripheralManager.startAdvertising method.

### Declaration
```swift
public enum StartAdvertisingResult
```
```

--------------------------------

### Restored Services Declaration

Source: https://polidea.github.io/RxBluetoothKit/Structs/CentralManagerRestoredState.html

Get an array of Service objects that were restored. These are services the CentralManager was scanning for when the app was terminated.

```swift
public var services: [Service] { get }
```

--------------------------------

### Initialize PeripheralManager with State Restoration

Source: https://polidea.github.io/RxBluetoothKit/Classes/PeripheralManager.html

Creates a PeripheralManager instance supporting Bluetooth state restoration. Ensure UI-related code observes results on the main thread if a background queue is used.

```Swift
public convenience init(queue: DispatchQueue = .main,
                        options: [String: AnyObject]? = nil,
                        onWillRestorePeripheralManagerState: OnWillRestorePeripheralManagerState? = nil)
```

--------------------------------

### Read Characteristic Value

Source: https://polidea.github.io/RxBluetoothKit/Classes/Peripheral.html

Triggers a read operation to get the current value of a characteristic. The observable completes after the value is read.

```APIDOC
## GET /readValue

### Description
Triggers a read operation to get the current value of a characteristic. The observable completes after the value is read.

### Method
GET

### Endpoint
`/readValue`

### Parameters
#### Path Parameters
None

#### Query Parameters
- **identifier** (CharacteristicIdentifier) - Required - The unique identifier of the characteristic.

#### Request Body
None

### Request Example
```json
{
  "identifier": "characteristic_uuid"
}
```

### Response
#### Success Response (200)
- **characteristic** (Characteristic) - Emitted with the characteristic containing the read value.

#### Response Example
```json
{
  "characteristic": {
    "uuid": "characteristic_uuid",
    "value": "read_value"
  }
}
```

#### Errors
- `BluetoothError.characteristicReadFailed`
- `BluetoothError.peripheralDisconnected`
- `BluetoothError.destroyed`
- `BluetoothError.bluetoothUnsupported`
- `BluetoothError.bluetoothUnauthorized`
- `BluetoothError.bluetoothPoweredOff`
- `BluetoothError.bluetoothInUnknownState`
- `BluetoothError.bluetoothResetting`
```

--------------------------------

### Service Discovery

Source: https://polidea.github.io/RxBluetoothKit/Classes/Peripheral.html

Method for discovering services on a connected peripheral.

```APIDOC
## discoverServices(_:)

### Description
Triggers discovery of specified services of the peripheral. If serviceUUIDs is nil, all available services are returned.

### Method
GET

### Parameters
#### Query Parameters
- **serviceUUIDs** ([CBUUID]?) - Optional - List of service UUIDs to discover.

### Response
- **Single<[Service]>** - Emits a list of discovered services.
```

--------------------------------

### Read peripheral RSSI in Swift

Source: https://polidea.github.io/RxBluetoothKit/Classes/Peripheral.html

Triggers a read of the peripheral's RSSI value. The read operation starts upon subscription.

```Swift
public func readRSSI() -> Single<(Peripheral, Int)>
```

--------------------------------

### Open L2CAP channel in Swift

Source: https://polidea.github.io/RxBluetoothKit/Classes/Peripheral.html

Opens an L2CAP channel for a peripheral using the specified PSM. Requires iOS 11, tvOS 11, or watchOS 4 or later.

```Swift
@available(iOS 11, OSX 10.14, tvOS 11, watchOS 4, *)
public func openL2CAPChannel(PSM: CBL2CAPPSM) -> Single<CBL2CAPChannel>
```

--------------------------------

### Initialization of CentralManager

Source: https://polidea.github.io/RxBluetoothKit/Classes/CentralManager.html

Creates a new instance of CentralManager with optional queue and initialization options.

```APIDOC
## init(queue:options:)

### Description
Creates a new CentralManager instance. By default, all operations and events are executed and received on the main thread.

### Parameters
#### Path Parameters
- **queue** (DispatchQueue) - Optional - Queue on which bluetooth callbacks are received. Defaults to main thread.
- **options** ([String: AnyObject]?) - Optional - An optional dictionary containing initialization options for a central manager.
```

--------------------------------

### BluetoothError Advertising In Progress Case

Source: https://polidea.github.io/RxBluetoothKit/Enums/BluetoothError.html

Indicates that Bluetooth advertising is already in progress. This error is emitted when an attempt is made to start advertising while it is already active.

```swift
case advertisingInProgress
```

--------------------------------

### BluetoothError Scan In Progress Case

Source: https://polidea.github.io/RxBluetoothKit/Enums/BluetoothError.html

Indicates that a Bluetooth scan is already in progress. This error is emitted when an attempt is made to start a new scan while one is active.

```swift
case scanInProgress
```

--------------------------------

### Compare Service instances

Source: https://polidea.github.io/RxBluetoothKit/Functions.html

Compares two services; they are considered equal if their UUIDs match.

```Swift
public func == (lhs: Service, rhs: Service) -> Bool
```

--------------------------------

### Service Discovery

Source: https://polidea.github.io/RxBluetoothKit/Classes/Peripheral.html

Methods for discovering and retrieving services associated with a Bluetooth peripheral.

```APIDOC
## GET /service

### Description
Retrieves a service with the given identifier. It's fetched from the cache if available, otherwise discovered via `discoverServices`.

### Method
GET

### Endpoint
`/service`

### Parameters
#### Query Parameters
- **identifier** (ServiceIdentifier) - Required - The unique identifier of the Service.

### Response
#### Success Response (200)
- **service** (Service) - The discovered Service object.

#### Response Example
```json
{
  "service": {
    "uuid": "180D",
    "isPrimary": true,
    "characteristics": []
  }
}
```

### Errors
- `RxError.noElements`
- `BluetoothError.servicesDiscoveryFailed`
- `BluetoothError.peripheralDisconnected`
- `BluetoothError.destroyed`
- `BluetoothError.bluetoothUnsupported`
- `BluetoothError.bluetoothUnauthorized`
- `BluetoothError.bluetoothPoweredOff`
- `BluetoothError.bluetoothInUnknownState`
- `BluetoothError.bluetoothResetting`
```

--------------------------------

### Get Maximum Write Value Length in Swift

Source: https://polidea.github.io/RxBluetoothKit/Classes/Peripheral.html

Returns the maximum amount of data in bytes that can be sent to a characteristic in a single write operation. This is relevant for `writeValue(_:for:type:)`.

```swift
@available(OSX 10.12, iOS 9.0, *) 
public func maximumWriteValueLength(for type: CBCharacteristicWriteType) -> Int
```

--------------------------------

### Compare Peripherals

Source: https://polidea.github.io/RxBluetoothKit/Functions.html

Compares two peripherals based on their identifiers.

```APIDOC
## POST /api/peripherals/compare

### Description
Compares two peripherals. Peripherals are the same when their identifiers are equal.

### Method
POST

### Endpoint
/api/peripherals/compare

### Parameters
#### Request Body
- **lhs** (Peripheral) - Required - The first peripheral to compare.
- **rhs** (Peripheral) - Required - The second peripheral to compare.

### Request Example
```json
{
  "lhs": {
    "identifier": "some-identifier-1"
  },
  "rhs": {
    "identifier": "some-identifier-1"
  }
}
```

### Response
#### Success Response (200)
- **result** (Boolean) - True if both peripherals are the same.

#### Response Example
```json
{
  "result": true
}
```
```

--------------------------------

### Get Characteristic by Identifier

Source: https://polidea.github.io/RxBluetoothKit/Classes/Peripheral.html

Retrieves a characteristic using its identifier. It checks the cache before discovering. Errors can occur due to discovery failures, peripheral disconnection, or Bluetooth state issues.

```swift
public func characteristic(with identifier: CharacteristicIdentifier) -> Single<Characteristic>
```

--------------------------------

### Peripheral Class Declarations

Source: https://polidea.github.io/RxBluetoothKit/Classes.html

Wraps Core Bluetooth peripheral interactions.

```Swift
public class Peripheral
```

```Swift
extension Peripheral: Equatable
```

--------------------------------

### RestoredState Structure (Deprecated)

Source: https://polidea.github.io/RxBluetoothKit/Structs.html

Deprecated structure, use CentralManager.init(queue:options:onWillRestoreCentralManagerState:) instead.

```APIDOC
## RestoredState

### Description
Deprecated, use CentralManager.init(queue:options:onWillRestoreCentralManagerState:) instead.

### Declaration
Swift
```swift
@available(*, deprecated, renamed: "CentralManagerRestoredStateType")
public struct RestoredState : CentralManagerRestoredStateType
```
```

--------------------------------

### Reactive Extension for RxBluetoothKitLog

Source: https://polidea.github.io/RxBluetoothKit/Extensions.html

This extension provides Reactive capabilities for the RxBluetoothKitLog class.

```APIDOC
## Reactive Extension

### Description
Provides Reactive extensions for the RxBluetoothKitLog base class.

### Declaration
```swift
extension Reactive where Base == RxBluetoothKitLog
```
```

--------------------------------

### Observe Opened L2CAP Channel

Source: https://polidea.github.io/RxBluetoothKit/Classes/PeripheralManager.html

Provides a continuous observer for peripheral manager L2CAP channel opening events.

```Swift
@available(iOS 11, tvOS 11, watchOS 4, *)
public func observeDidOpenL2CAPChannel() -> Observable<(CBL2CAPChannel?, Error?)>
```

--------------------------------

### Establish Peripheral Connection

Source: https://polidea.github.io/RxBluetoothKit/Classes/Peripheral.html

Establishes a connection with the peripheral. This method directly calls CentralManager.establishConnection(with:options:). Observable can end with various Bluetooth or peripheral-specific errors.

```swift
public func establishConnection(options: [String : Any]? = nil) -> Observable<Peripheral>
```

--------------------------------

### observeDidOpenL2CAPChannel

Source: https://polidea.github.io/RxBluetoothKit/Classes/PeripheralManager.html

A continuous observer for peripheral manager didOpen channel events.

```APIDOC
## observeDidOpenL2CAPChannel()

### Description
An infinite stream that emits events whenever a peripheral manager opens an L2CAP channel.

### Response
#### Success Response (200)
- **(CBL2CAPChannel?, Error?)** (Tuple) - Emits the opened channel or an error if the operation failed.

### Errors
- BluetoothError.destroyed
- BluetoothError.bluetoothUnsupported
- BluetoothError.bluetoothUnauthorized
- BluetoothError.bluetoothPoweredOff
- BluetoothError.bluetoothInUnknownState
- BluetoothError.bluetoothResetting
```

--------------------------------

### BluetoothState Enumeration

Source: https://polidea.github.io/RxBluetoothKit/Enums.html

Describes the current Bluetooth state, equivalent to CBManagerState.

```APIDOC
## BluetoothState

### Description
Type describing bluetooth state, equivalent to CBManagerState.

### Declaration
```swift
public enum BluetoothState : Int
```
```

--------------------------------

### Service Class Declarations

Source: https://polidea.github.io/RxBluetoothKit/Classes.html

Wraps CBService functionality.

```Swift
public class Service
```

```Swift
extension Service: Equatable
```

--------------------------------

### Initialize CentralManager

Source: https://polidea.github.io/RxBluetoothKit/Classes/CentralManager.html

Initializes a new CentralManager instance with optional queue configuration and state restoration handling.

```APIDOC
## INITIALIZE CentralManager

### Description
Creates a new CentralManager instance, which supports Bluetooth state restoration.

### Parameters
#### Parameters
- **queue** (DispatchQueue) - Optional - Queue on which bluetooth callbacks are received. By default main thread is used.
- **options** ([String: AnyObject]) - Optional - An optional dictionary containing initialization options for a central manager.
- **onWillRestoreCentralManagerState** (OnWillRestoreCentralManagerState) - Optional - Closure called when state has been restored.

### Request Example
```swift
let centralManager = CentralManager(queue: .main, options: nil, onWillRestoreCentralManagerState: { state in 
    // Handle restoration
})
```
```

--------------------------------

### Descriptor Class Overview

Source: https://polidea.github.io/RxBluetoothKit/Classes/Descriptor.html

Provides an overview of the Descriptor class, its purpose, and its relationship with CoreBluetooth.

```APIDOC
## Descriptor Class

### Description

The `Descriptor` class in RxBluetoothKit provides a reactive wrapper around CoreBluetooth's `CBDescriptor` functionality. It allows for observing writes to a descriptor and reading or writing its value.

### Properties

- **descriptor** (`CBDescriptor`) - The underlying CoreBluetooth descriptor instance.
- **characteristic** (`Characteristic`) - The characteristic to which this descriptor belongs.
- **uuid** (`CBUUID`) - The Bluetooth UUID of the Descriptor instance.
- **value** (`Any?`) - The value of the descriptor. This can be read or written.

### Methods

- **observeWrite()**
  - **Description**: Observes writes that occur for the descriptor. This is an infinite stream.
  - **Return Value**: `Observable<Descriptor>` - Emits the `Descriptor` instance upon each write.
  - **Errors**: `BluetoothError.descriptorWriteFailed`, `BluetoothError.peripheralDisconnected`, `BluetoothError.destroyed`, `BluetoothError.bluetoothUnsupported`, `BluetoothError.bluetoothUnauthorized`, `BluetoothError.bluetoothPoweredOff`, `BluetoothError.bluetoothInUnknownState`, `BluetoothError.bluetoothResetting`.

- **writeValue(_:)**
  - **Description**: Triggers the writing of data to the descriptor. The write operation is initiated upon subscription.
  - **Parameters**:
    - `data` (`Data`) - The data to be written to the descriptor.
  - **Return Value**: `Single<Descriptor>` - Emits the `Descriptor` instance upon successful write.
  - **Errors**: `BluetoothError.descriptorWriteFailed`, `BluetoothError.peripheralDisconnected`, `BluetoothError.destroyed`, `BluetoothError.bluetoothUnsupported`, `BluetoothError.bluetoothUnauthorized`, `BluetoothError.bluetoothPoweredOff`, `BluetoothError.bluetoothInUnknownState`, `BluetoothError.bluetoothResetting`.

- **observeValueUpdate()**
  - **Description**: Observes updates to the descriptor's value. This is an infinite stream.
  - **Return Value**: `Observable<Descriptor>` - Emits the `Descriptor` instance whenever its value is updated.
  - **Errors**: `BluetoothError.descriptorReadFailed`, `BluetoothError.peripheralDisconnected`, `BluetoothError.destroyed`, `BluetoothError.bluetoothUnsupported`, `BluetoothError.bluetoothUnauthorized`, `BluetoothError.bluetoothPoweredOff`, `BluetoothError.bluetoothInUnknownState`, `BluetoothError.bluetoothResetting`.

- **readValue()**
  - **Description**: Triggers the reading of the descriptor's current value.
  - **Return Value**: `Single<Descriptor>` - Emits the `Descriptor` instance when the value is ready to be read.
  - **Errors**: `BluetoothError.descriptorReadFailed`, `BluetoothError.peripheralDisconnected`, `BluetoothError.destroyed`, `BluetoothError.bluetoothUnsupported`, `BluetoothError.bluetoothUnauthorized`, `BluetoothError.bluetoothPoweredOff`, `BluetoothError.bluetoothInUnknownState`, `BluetoothError.bluetoothResetting`.
```

--------------------------------

### Peripheral Connection Management

Source: https://polidea.github.io/RxBluetoothKit/Classes/CentralManager.html

APIs for establishing and managing connections with Bluetooth peripherals.

```APIDOC
## POST /api/establishConnection

### Description
Establishes a connection with a given Peripheral. Upon successful connection, it emits an event with the Peripheral object, enabling subsequent method calls that require a connection. The connection is automatically disconnected when the resulting Observable is unsubscribed. If the connection is interrupted or fails, the Observable will also unsubscribe, emitting `BluetoothError.peripheralConnectionFailed` or `BluetoothError.peripheralDisconnected`. Optional parameters can be provided to customize connection behavior.

### Method
POST

### Endpoint
/api/establishConnection

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **peripheral** (Peripheral) - Required - The Peripheral to connect to.
- **options** (Dictionary[String, Any]?) - Optional - Dictionary to customize connection behavior.

### Request Example
```json
{
  "peripheral": {"uuid": "...", "name": "..."},
  "options": {"someOption": "value"}
}
```

### Response
#### Success Response (200)
- **peripheral** (Peripheral) - The connected Peripheral object.

#### Response Example
```json
{
  "peripheral": {"uuid": "...", "name": "..."}
}
```

### Errors
- `BluetoothError.peripheralIsAlreadyObservingConnection`
- `BluetoothError.peripheralConnectionFailed`
- `BluetoothError.destroyed`
- `BluetoothError.bluetoothUnsupported`
- `BluetoothError.bluetoothUnauthorized`
- `BluetoothError.bluetoothPoweredOff`
- `BluetoothError.bluetoothInUnknownState`
- `BluetoothError.bluetoothResetting`
```

--------------------------------

### StartAdvertisingResult Enum Declaration

Source: https://polidea.github.io/RxBluetoothKit/Enums/StartAdvertisingResult.html

The base enumeration definition for advertising results.

```Swift
public enum StartAdvertisingResult
```

--------------------------------

### PeripheralManager Initialization

Source: https://polidea.github.io/RxBluetoothKit/Classes/PeripheralManager.html

Initializes a new PeripheralManager instance. By default, operations and events are handled on the main thread. Ensure UI-related code is observed on the main thread if a background queue is provided.

```APIDOC
## PeripheralManager Initialization

### Description
Creates a new `PeripheralManager` instance. By default, all operations and events are executed and received on the main thread.

**Warning**: If you pass a background queue to the method, make sure to observe results on the main thread for UI-related code.

### Method
`init(queue:options:)`

### Parameters
- **queue** (DispatchQueue) - Optional - The queue on which Bluetooth callbacks are received. Defaults to the main thread.
- **options** ([String: AnyObject]?) - Optional - An optional dictionary containing initialization options for a peripheral manager. Refer to Peripheral Manager initialization options for more details.
```

--------------------------------

### Initialize CentralManager with State Restoration

Source: https://polidea.github.io/RxBluetoothKit/Classes/CentralManager.html

Initializes a new CentralManager instance. Note that background queues require UI updates to be dispatched to the main thread.

```Swift
@available(*, deprecated, renamed: "CentralManager.init(queue:options:onWillRestoreCentralManagerState:﹚")
public convenience init(queue: DispatchQueue = .main,
                        options: [String: AnyObject]? = nil,
                        onWillRestoreState: OnWillRestoreState? = nil)
```

```Swift
public convenience init(queue: DispatchQueue = .main,
                        options: [String: AnyObject]? = nil,
                        onWillRestoreCentralManagerState: OnWillRestoreCentralManagerState? = nil)
```

--------------------------------

### Observe Peripheral Connection Events

Source: https://polidea.github.io/RxBluetoothKit/Classes/CentralManager.html

Emits a Peripheral instance when it connects. This is an infinite stream that can end with Bluetooth-related errors. It can observe any peripheral or a specific one if provided.

```swift
public func observeConnect(for peripheral: Peripheral? = nil) -> Observable<Peripheral>
```

--------------------------------

### Scan for Peripherals with CentralManager

Source: https://polidea.github.io/RxBluetoothKit/Classes.html

Initializes a scan for peripherals after ensuring the Bluetooth state is powered on.

```Swift
let disposable = centralManager.observeStateWithInitialValue()
    .filter { $0 == .poweredOn }
    .take(1)
    .flatMap { centralManager.scanForPeripherals(nil) }
```

--------------------------------

### Responding to Requests

Source: https://polidea.github.io/RxBluetoothKit/Classes/PeripheralManager.html

Responds to a given attribute protocol request.

```APIDOC
## POST /websites/polidea_github_io_rxbluetoothkit/respond

### Description
Responds to a `CBATTRequest` with a specified result code. This is a wrapper for `CBPeripheralManager.respond(to:withResult:)`.

### Method
POST

### Endpoint
/websites/polidea_github_io_rxbluetoothkit/respond

### Parameters
#### Request Body
- **request** (CBATTRequest) - Required - The attribute request to respond to.
- **result** (CBATTError.Code) - Required - The result code for the response.

### Request Example
```json
{
  "request": "<cbattrequest_object>",
  "result": 0
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates the response was sent successfully.

#### Response Example
```json
{
  "message": "Response sent successfully."
}
```
```

--------------------------------

### Discover Included Services in Swift

Source: https://polidea.github.io/RxBluetoothKit/Classes/Peripheral.html

Triggers the discovery of included services for a given service. Discovery occurs upon subscription. Handles errors like discovery failure or peripheral disconnection.

```swift
public func discoverIncludedServices(_ includedServiceUUIDs: [CBUUID]?, for service: Service) -> Single<[Service]>
```

--------------------------------

### Service Management

Source: https://polidea.github.io/RxBluetoothKit/Classes/PeripheralManager.html

Methods for managing services within the PeripheralManager.

```APIDOC
## POST /websites/polidea_github_io_rxbluetoothkit/services

### Description
Removes a specific service from the peripheral.

### Method
POST

### Endpoint
/websites/polidea_github_io_rxbluetoothkit/services

### Parameters
#### Request Body
- **service** (CBMutableService) - Required - The service to remove.

### Request Example
```json
{
  "service": "<service_object>"
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates successful removal.

#### Response Example
```json
{
  "message": "Service removed successfully."
}
```
```

```APIDOC
## DELETE /websites/polidea_github_io_rxbluetoothkit/services

### Description
Removes all services from the peripheral.

### Method
DELETE

### Endpoint
/websites/polidea_github_io_rxbluetoothkit/services

### Response
#### Success Response (200)
- **message** (string) - Indicates successful removal of all services.

#### Response Example
```json
{
  "message": "All services removed successfully."
}
```
```

--------------------------------

### Observe State with Initial Value

Source: https://polidea.github.io/RxBluetoothKit/Protocols/ManagerType.html

Observes changes to the Bluetooth state, emitting the current state immediately upon subscription.

```Swift
func observeStateWithInitialValue() -> Observable<BluetoothState>
```

--------------------------------

### Subscriber Readiness Observation

Source: https://polidea.github.io/RxBluetoothKit/Classes/PeripheralManager.html

Observes when the peripheral manager is ready to update subscribers.

```APIDOC
## GET /websites/polidea_github_io_rxbluetoothkit/observe/isReadyToUpdateSubscribers

### Description
Continuously observes `CBPeripheralManagerDelegate.peripheralManagerIsReady(toUpdateSubscribers:)` events. This is an infinite stream and may end with Bluetooth-related errors.

### Method
GET

### Endpoint
/websites/polidea_github_io_rxbluetoothkit/observe/isReadyToUpdateSubscribers

### Response
#### Success Response (200)
- **message** (string) - Emitted when the peripheral manager is ready to update subscribers.

#### Response Example
```json
{
  "message": "Peripheral manager is ready."
}
```

### Errors
- `BluetoothError.destroyed`
- `BluetoothError.bluetoothUnsupported`
- `BluetoothError.bluetoothUnauthorized`
- `BluetoothError.bluetoothPoweredOff`
- `BluetoothError.bluetoothInUnknownState`
- `BluetoothError.bluetoothResetting
```

--------------------------------

### Log Message with String

Source: https://polidea.github.io/RxBluetoothKit/Protocols/Logger.html

Logs a message using standard String parameters for file and function metadata.

```Swift
func log(
    _ message: @autoclosure () -> String,
    level: RxBluetoothKitLog.LogLevel,
    file: String,
    function: String,
    line: UInt
)
```

--------------------------------

### Check connectability

Source: https://polidea.github.io/RxBluetoothKit/Structs/AdvertisementData.html

Determines if the peripheral is currently connectable.

```Swift
public var isConnectable: Bool? { get }
```

--------------------------------

### Characteristic Methods

Source: https://polidea.github.io/RxBluetoothKit/Classes/Characteristic.html

Methods for interacting with Bluetooth characteristics, including descriptor discovery and observation of state changes.

```APIDOC
## discoverDescriptors()

### Description
Triggers the discovery of descriptors for the characteristic.

### Method
Function

### Return Value
- **Single<[Descriptor]>** - Emits an array of Descriptor instances once discovered.

---

## observeWrite()

### Description
Allows observation of write operations performed on the characteristic.

### Method
Function

### Return Value
- **Observable<Characteristic>** - An infinite stream emitting the Characteristic instance whenever a write occurs.

---

## observeNotifyValue()

### Description
Allows monitoring of changes to the isNotifying state of the characteristic.

### Method
Function

### Return Value
- **Observable<Characteristic>** - Emits the Characteristic when the isNotifying value changes.

---

## writeValue(_:type:)

### Description
Triggers a write operation of data to the characteristic. Behavior depends on the CBCharacteristicWriteType provided.

### Parameters
- **data** (Data) - The data to write.
- **type** (CBCharacteristicWriteType) - The write type (withResponse or withoutResponse).

### Return Value
- **Observable<Characteristic>** - Emits the Characteristic instance based on the write confirmation status.
```

--------------------------------

### Observe Bluetooth State with Initial Value

Source: https://polidea.github.io/RxBluetoothKit/Classes/CentralManager.html

Returns an observable that emits the current Bluetooth state immediately and any subsequent changes.

```swift
public func observeStateWithInitialValue() -> Observable<BluetoothState>
```

--------------------------------

### RxBluetoothKitLogger

Source: https://polidea.github.io/RxBluetoothKit/Enums/RxBluetoothKitLogger.html

Namespace for assigning the default logger.

```APIDOC
## RxBluetoothKitLogger

### Description
Namespace for assigning the default logger.

### Declaration
Swift
```swift
public enum RxBluetoothKitLogger
```
```

--------------------------------

### Connection and Disconnection Observing

Source: https://polidea.github.io/RxBluetoothKit/Classes/CentralManager.html

APIs for observing connection and disconnection events for Bluetooth peripherals.

```APIDOC
## POST /api/observeConnect

### Description
Emits a Peripheral instance when it is connected. This is an infinite stream and does not complete.

### Method
POST

### Endpoint
/api/observeConnect

### Parameters
#### Path Parameters
None

#### Query Parameters
- **peripheral** (Peripheral?) - Optional - The Peripheral to observe for connection. If not specified, observes any Peripheral.

### Request Example
```json
{
  "peripheral": {"uuid": "...", "name": "..."}
}
```

### Response
#### Success Response (200)
- **peripheral** (Peripheral) - The Peripheral that was connected.

#### Response Example
```json
{
  "peripheral": {"uuid": "...", "name": "..."}
}
```

### Errors
- `BluetoothError.destroyed`
- `BluetoothError.bluetoothUnsupported`
- `BluetoothError.bluetoothUnauthorized`
- `BluetoothError.bluetoothPoweredOff`
- `BluetoothError.bluetoothInUnknownState`
- `BluetoothError.bluetoothResetting`
```

```APIDOC
## POST /api/observeDisconnect

### Description
Emits a Peripheral instance when it is disconnected. This is an infinite stream and does not complete.

### Method
POST

### Endpoint
/api/observeDisconnect

### Parameters
#### Path Parameters
None

#### Query Parameters
- **peripheral** (Peripheral?) - Optional - The Peripheral to observe for disconnection. If not specified, observes any Peripheral.

### Request Example
```json
{
  "peripheral": {"uuid": "...", "name": "..."}
}
```

### Response
#### Success Response (200)
- **peripheral** (Peripheral) - The Peripheral that was disconnected.
- **reason** (DisconnectionReason?) - Optional - Information about the cause of disconnection.

#### Response Example
```json
{
  "peripheral": {"uuid": "...", "name": "..."},
  "reason": "connection terminated by user"
}
```

### Errors
- `BluetoothError.destroyed`
- `BluetoothError.bluetoothUnsupported`
- `BluetoothError.bluetoothUnauthorized`
- `BluetoothError.bluetoothPoweredOff`
- `BluetoothError.bluetoothInUnknownState`
- `BluetoothError.bluetoothResetting`
```

--------------------------------

### Retrieve Connected Peripherals by Services

Source: https://polidea.github.io/RxBluetoothKit/Classes/CentralManager.html

Retrieves a list of Peripherals that are currently connected and offer all specified Service UUIDs. This is useful for finding devices with specific functionalities.

```swift
public func retrieveConnectedPeripherals(withServices serviceUUIDs: [CBUUID]) -> [Peripheral]
```

--------------------------------

### Establish Peripheral Connection

Source: https://polidea.github.io/RxBluetoothKit/Classes/CentralManager.html

Establishes a connection with a specified Peripheral. The connection is managed by an Observable which automatically disconnects upon unsubscription or if the connection is interrupted. Errors like `peripheralConnectionFailed` or `peripheralDisconnected` can be emitted.

```swift
public func establishConnection(_ peripheral: Peripheral, options: [String : Any]? = nil) -> Observable<Peripheral>
```

--------------------------------

### Compare Services

Source: https://polidea.github.io/RxBluetoothKit/Functions.html

Compares two services based on their UUIDs.

```APIDOC
## POST /api/services/compare

### Description
Compares two services. They are the same if their UUIDs are the same.

### Method
POST

### Endpoint
/api/services/compare

### Parameters
#### Request Body
- **lhs** (Service) - Required - The first service to compare.
- **rhs** (Service) - Required - The second service to compare.

### Request Example
```json
{
  "lhs": {
    "uuid": "some-uuid-1"
  },
  "rhs": {
    "uuid": "some-uuid-1"
  }
}
```

### Response
#### Success Response (200)
- **result** (Boolean) - True if services are the same.

#### Response Example
```json
{
  "result": true
}
```
```

--------------------------------

### StartAdvertisingResult Enumeration

Source: https://polidea.github.io/RxBluetoothKit/Enums/StartAdvertisingResult.html

The StartAdvertisingResult enum indicates the outcome of the startAdvertising method.

```APIDOC
## StartAdvertisingResult

Enum result that is returned as a result of `PeripheralManager.startAdvertising` method.

### Cases

*   **`started`**
    Advertising started properly with specified `advertisementData`.
    #### Declaration
    Swift
    ```swift
    case started
    ```

*   **`attachedToExternalAdvertising(_:)`**
    This is a special case meaning that there is already ongoing advertising that has been started outside of `RxBluetoothKit` library and `PeripherlManager.startAdvertising` did only attached to ongoing advertising without calling `CBPeripheralManager.startAdvertising`. The reason behind that is that we want to give user possibility to stop advertising in such state. In most cases it happens when app went from background with ongoing advertising - in that case you will receive `RestoredAdvertisementData` param, so you can know with what `advertisementData` it was started before app went background. WARNING: remember that this is not really calling `CBPeripheralManager.startAdvertising` so it might be not started with `advertisementData` param that you’ve provided. If you want to start with different `advertisementData` then you will need to dispose advertising observable and call `startAdvertising` again.
    #### Declaration
    Swift
    ```swift
    case attachedToExternalAdvertising(RestoredAdvertisementData?)
    ```
```

--------------------------------

### AdvertisementData Structure

Source: https://polidea.github.io/RxBluetoothKit/Structs.html

A convenience class for reading advertisement data.

```APIDOC
## AdvertisementData

### Description
Convenience class which helps reading advertisement data.

### Declaration
Swift
```swift
public struct AdvertisementData
```
```

--------------------------------

### RxBluetoothKitLogger Enumeration

Source: https://polidea.github.io/RxBluetoothKit/Enums.html

Namespace for assigning the default logger.

```APIDOC
## RxBluetoothKitLogger

### Description
Namespace for assigning the default logger.

### Declaration
```swift
public enum RxBluetoothKitLogger
```
```

--------------------------------

### Retrieving Lists of Peripherals

Source: https://polidea.github.io/RxBluetoothKit/Classes/CentralManager.html

APIs for retrieving lists of Bluetooth peripherals known to the Central Manager.

```APIDOC
## GET /api/retrieveConnectedPeripherals

### Description
Returns a list of Peripherals currently connected to the Central Manager that contain all specified Service UUIDs.

### Method
GET

### Endpoint
/api/retrieveConnectedPeripherals

### Parameters
#### Path Parameters
None

#### Query Parameters
- **serviceUUIDs** ([CBUUID]) - Required - A list of Service UUIDs.

### Request Example
```
GET /api/retrieveConnectedPeripherals?serviceUUIDs=180D,180F
```

### Response
#### Success Response (200)
- **peripherals** ([Peripheral]) - A list of connected Peripherals matching the criteria.

#### Response Example
```json
[
  {"uuid": "...", "name": "..."},
  {"uuid": "...", "name": "..."}
]
```
```

```APIDOC
## GET /api/retrievePeripherals

### Description
Returns a list of Peripherals by their identifiers that are known to the Central Manager.

### Method
GET

### Endpoint
/api/retrievePeripherals

### Parameters
#### Path Parameters
None

#### Query Parameters
- **identifiers** ([UUID]) - Required - A list of Peripheral identifiers to retrieve.

### Request Example
```
GET /api/retrievePeripherals?identifiers=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx,yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy
```

### Response
#### Success Response (200)
- **peripherals** ([Peripheral]) - A list of retrieved Peripherals.

#### Response Example
```json
[
  {"uuid": "...", "name": "..."},
  {"uuid": "...", "name": "..."}
]
```
```

--------------------------------

### Observe peripheral service modifications in Swift

Source: https://polidea.github.io/RxBluetoothKit/Classes/Peripheral.html

Provides an infinite stream of service modifications for a peripheral. Emits tuples containing the peripheral and the updated list of services.

```Swift
public func observeServicesModification() -> Observable<(Peripheral, [Service])>
```

--------------------------------

### Logger Protocol Methods

Source: https://polidea.github.io/RxBluetoothKit/Protocols/Logger.html

Methods for logging messages and managing log levels within the RxBluetoothKit library.

```APIDOC
## log(_:level:file:function:line:) (StaticString)

### Description
Logs a message using StaticString parameters for file and function names.

### Parameters
- **message** (@autoclosure () -> String) - The message to be logged.
- **level** (RxBluetoothKitLog.LogLevel) - The severity of the message.
- **file** (StaticString) - The file name where the message was created.
- **function** (StaticString) - The function name where the message was created.
- **line** (UInt) - The line number where the message was created.

## log(_:level:file:function:line:) (String)

### Description
Logs a message using regular String parameters for file and function names.

### Parameters
- **message** (@autoclosure () -> String) - The message to be logged.
- **level** (RxBluetoothKitLog.LogLevel) - The severity of the message.
- **file** (String) - The file name where the message was created.
- **function** (String) - The function name where the message was created.
- **line** (UInt) - The line number where the message was created.

## setLogLevel(_:)

### Description
Sets the new log level for the logger.

### Parameters
- **logLevel** (RxBluetoothKitLog.LogLevel) - New log level to be applied.

## getLogLevel()

### Description
Retrieves the currently set log level.

### Response
- **Return Value** (RxBluetoothKitLog.LogLevel) - Currently set log level.
```

--------------------------------

### Define BluetoothState Enumeration

Source: https://polidea.github.io/RxBluetoothKit/Enums/BluetoothState.html

The base definition for the BluetoothState enumeration.

```Swift
public enum BluetoothState : Int
```

--------------------------------

### Open L2CAP Channel

Source: https://polidea.github.io/RxBluetoothKit/Classes/Peripheral.html

Allows opening an L2CAP channel for a Peripheral instance. Available on iOS 11, tvOS 11, watchOS 4 and later.

```APIDOC
## POST /openL2CAPChannel

### Description
Allows opening an L2CAP channel for a Peripheral instance. Available on iOS 11, tvOS 11, watchOS 4 and later.

### Method
POST

### Endpoint
/openL2CAPChannel

### Parameters
#### Request Body
- **PSM** (CBL2CAPPSM) - Required - The Protocol/Service Multiplexer of the channel.

### Request Example
```json
{
  "PSM": 1001
}
```

### Response
#### Success Response (200)
- **channel** (CBL2CAPChannel) - The opened L2CAP channel.

#### Response Example
```json
{
  "channel": {
    "channelID": 123,
    "sourcePSM": 1001,
    "destinationPSM": 1002
  }
}
```

### Errors
- `BluetoothError.openingL2CAPChannelFailed`
- `BluetoothError.peripheralDisconnected`
- `BluetoothError.destroyed`
- `BluetoothError.bluetoothUnsupported`
- `BluetoothError.bluetoothUnauthorized`
- `BluetoothError.bluetoothPoweredOff`
- `BluetoothError.bluetoothInUnknownState`
- `BluetoothError.bluetoothResetting
```

--------------------------------

### Sample CharacteristicIdentifier Implementation

Source: https://polidea.github.io/RxBluetoothKit/Protocols/CharacteristicIdentifier.html

Provides a sample enum implementation of the CharacteristicIdentifier protocol. This enum defines characteristics for a device and their associated UUIDs and services.

```swift
enum DeviceCharacteristic: String, CharacteristicIdentifier {
    case manufacturerName = "2A29"
    var uuid: CBUUID {
        return CBUUID(string: self.rawValue)
    }
    var service: ServiceIdentifier {
        switch self {
        case .ManufacturerName:
            return XXXService.DeviceInformation
        }
    }

}
```

--------------------------------

### Observe peripheral name updates in Swift

Source: https://polidea.github.io/RxBluetoothKit/Classes/Peripheral.html

Provides an infinite stream of name changes for a peripheral. The stream emits tuples containing the peripheral and its new name.

```Swift
public func observeNameUpdate() -> Observable<(Peripheral, String?)>
```

--------------------------------

### Descriptor Method: observeWrite()

Source: https://polidea.github.io/RxBluetoothKit/Classes/Descriptor.html

Observes writes that happened for the descriptor. This is an infinite stream and does not complete.

```swift
public func observeWrite() -> Observable<Descriptor>
```

--------------------------------

### Declare CBCentralManager Property

Source: https://polidea.github.io/RxBluetoothKit/Classes/CentralManager.html

This property is an implementation of CBCentralManager.

```swift
public let manager: CBCentralManager
```

--------------------------------

### Observe Characteristic Value Updates and Set Notification

Source: https://polidea.github.io/RxBluetoothKit/Classes/Peripheral.html

Sets up characteristic notifications to receive callbacks when the characteristic's value changes. This is an infinite stream.

```APIDOC
## POST /observeValueUpdateAndSetNotification

### Description
Sets up characteristic notifications to receive callbacks when the characteristic's value changes. This is an infinite stream. Notification is automatically unregistered upon observable unsubscription.

### Method
POST

### Endpoint
`/observeValueUpdateAndSetNotification`

### Parameters
#### Path Parameters
None

#### Query Parameters
- **identifier** (CharacteristicIdentifier) - Required - The unique identifier of the characteristic.

#### Request Body
None

### Request Example
```json
{
  "identifier": "characteristic_uuid"
}
```

### Response
#### Success Response (200)
- **characteristic** (Characteristic) - Emitted on every notification change.

#### Response Example
```json
{
  "characteristic": {
    "uuid": "characteristic_uuid",
    "value": "notification_value"
  }
}
```

#### Errors
- `BluetoothError.characteristicReadFailed`
- `BluetoothError.peripheralDisconnected`
- `BluetoothError.destroyed`
- `BluetoothError.bluetoothUnsupported`
- `BluetoothError.bluetoothUnauthorized`
- `BluetoothError.bluetoothPoweredOff`
- `BluetoothError.bluetoothInUnknownState`
- `BluetoothError.bluetoothResetting`
```

--------------------------------

### Define RxBluetoothKitLog Class

Source: https://polidea.github.io/RxBluetoothKit/Classes/RxBluetoothKitLog.html

The base class definition for RxBluetoothKit logging functionality.

```Swift
public class RxBluetoothKitLog : ReactiveCompatible
```
Tokens:
Raw