Skip to content

bluetooth_emulation

CentralState

Bases: Enum

Indicates the various states of Central.

Source code in zendriver/cdp/bluetooth_emulation.py 
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class CentralState(enum.Enum):
    """
    Indicates the various states of Central.
    """

    ABSENT = "absent"
    POWERED_OFF = "powered-off"
    POWERED_ON = "powered-on"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> CentralState:
        return cls(json)

ABSENT = 'absent' class-attribute instance-attribute

POWERED_OFF = 'powered-off' class-attribute instance-attribute

POWERED_ON = 'powered-on' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/bluetooth_emulation.py 
27
28
29
@classmethod
def from_json(cls, json: str) -> CentralState:
    return cls(json)

to_json()

Source code in zendriver/cdp/bluetooth_emulation.py 
24
25
def to_json(self) -> str:
    return self.value

CharacteristicOperationReceived dataclass

Event for when a characteristic operation of type to the characteristic respresented by characteristicId happened. data and writeType is expected to exist when type is write.

Source code in zendriver/cdp/bluetooth_emulation.py 
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
@event_class("BluetoothEmulation.characteristicOperationReceived")
@dataclass
class CharacteristicOperationReceived:
    """
    Event for when a characteristic operation of ``type`` to the characteristic
    respresented by ``characteristicId`` happened. ``data`` and ``writeType`` is
    expected to exist when ``type`` is write.
    """

    characteristic_id: str
    type_: CharacteristicOperationType
    data: typing.Optional[str]
    write_type: typing.Optional[CharacteristicWriteType]

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> CharacteristicOperationReceived:
        return cls(
            characteristic_id=str(json["characteristicId"]),
            type_=CharacteristicOperationType.from_json(json["type"]),
            data=str(json["data"]) if json.get("data", None) is not None else None,
            write_type=CharacteristicWriteType.from_json(json["writeType"])
            if json.get("writeType", None) is not None
            else None,
        )

characteristic_id: str instance-attribute

data: typing.Optional[str] instance-attribute

type_: CharacteristicOperationType instance-attribute

write_type: typing.Optional[CharacteristicWriteType] instance-attribute

__init__(characteristic_id, type_, data, write_type)

from_json(json) classmethod

Source code in zendriver/cdp/bluetooth_emulation.py 
622
623
624
625
626
627
628
629
630
631
@classmethod
def from_json(cls, json: T_JSON_DICT) -> CharacteristicOperationReceived:
    return cls(
        characteristic_id=str(json["characteristicId"]),
        type_=CharacteristicOperationType.from_json(json["type"]),
        data=str(json["data"]) if json.get("data", None) is not None else None,
        write_type=CharacteristicWriteType.from_json(json["writeType"])
        if json.get("writeType", None) is not None
        else None,
    )

CharacteristicOperationType

Bases: Enum

Indicates the various types of characteristic operation.

Source code in zendriver/cdp/bluetooth_emulation.py 
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
class CharacteristicOperationType(enum.Enum):
    """
    Indicates the various types of characteristic operation.
    """

    READ = "read"
    WRITE = "write"
    SUBSCRIBE_TO_NOTIFICATIONS = "subscribe-to-notifications"
    UNSUBSCRIBE_FROM_NOTIFICATIONS = "unsubscribe-from-notifications"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> CharacteristicOperationType:
        return cls(json)

READ = 'read' class-attribute instance-attribute

SUBSCRIBE_TO_NOTIFICATIONS = 'subscribe-to-notifications' class-attribute instance-attribute

UNSUBSCRIBE_FROM_NOTIFICATIONS = 'unsubscribe-from-notifications' class-attribute instance-attribute

WRITE = 'write' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/bluetooth_emulation.py 
78
79
80
@classmethod
def from_json(cls, json: str) -> CharacteristicOperationType:
    return cls(json)

to_json()

Source code in zendriver/cdp/bluetooth_emulation.py 
75
76
def to_json(self) -> str:
    return self.value

CharacteristicProperties dataclass

Describes the properties of a characteristic. This follows Bluetooth Core Specification BT 4.2 Vol 3 Part G 3.3.1. Characteristic Properties.

Source code in zendriver/cdp/bluetooth_emulation.py 
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
@dataclass
class CharacteristicProperties:
    """
    Describes the properties of a characteristic. This follows Bluetooth Core
    Specification BT 4.2 Vol 3 Part G 3.3.1. Characteristic Properties.
    """

    broadcast: typing.Optional[bool] = None

    read: typing.Optional[bool] = None

    write_without_response: typing.Optional[bool] = None

    write: typing.Optional[bool] = None

    notify: typing.Optional[bool] = None

    indicate: typing.Optional[bool] = None

    authenticated_signed_writes: typing.Optional[bool] = None

    extended_properties: typing.Optional[bool] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        if self.broadcast is not None:
            json["broadcast"] = self.broadcast
        if self.read is not None:
            json["read"] = self.read
        if self.write_without_response is not None:
            json["writeWithoutResponse"] = self.write_without_response
        if self.write is not None:
            json["write"] = self.write
        if self.notify is not None:
            json["notify"] = self.notify
        if self.indicate is not None:
            json["indicate"] = self.indicate
        if self.authenticated_signed_writes is not None:
            json["authenticatedSignedWrites"] = self.authenticated_signed_writes
        if self.extended_properties is not None:
            json["extendedProperties"] = self.extended_properties
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> CharacteristicProperties:
        return cls(
            broadcast=bool(json["broadcast"])
            if json.get("broadcast", None) is not None
            else None,
            read=bool(json["read"]) if json.get("read", None) is not None else None,
            write_without_response=bool(json["writeWithoutResponse"])
            if json.get("writeWithoutResponse", None) is not None
            else None,
            write=bool(json["write"]) if json.get("write", None) is not None else None,
            notify=bool(json["notify"])
            if json.get("notify", None) is not None
            else None,
            indicate=bool(json["indicate"])
            if json.get("indicate", None) is not None
            else None,
            authenticated_signed_writes=bool(json["authenticatedSignedWrites"])
            if json.get("authenticatedSignedWrites", None) is not None
            else None,
            extended_properties=bool(json["extendedProperties"])
            if json.get("extendedProperties", None) is not None
            else None,
        )

authenticated_signed_writes: typing.Optional[bool] = None class-attribute instance-attribute

broadcast: typing.Optional[bool] = None class-attribute instance-attribute

extended_properties: typing.Optional[bool] = None class-attribute instance-attribute

indicate: typing.Optional[bool] = None class-attribute instance-attribute

notify: typing.Optional[bool] = None class-attribute instance-attribute

read: typing.Optional[bool] = None class-attribute instance-attribute

write: typing.Optional[bool] = None class-attribute instance-attribute

write_without_response: typing.Optional[bool] = None class-attribute instance-attribute

__init__(broadcast=None, read=None, write_without_response=None, write=None, notify=None, indicate=None, authenticated_signed_writes=None, extended_properties=None)

from_json(json) classmethod

Source code in zendriver/cdp/bluetooth_emulation.py 
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
@classmethod
def from_json(cls, json: T_JSON_DICT) -> CharacteristicProperties:
    return cls(
        broadcast=bool(json["broadcast"])
        if json.get("broadcast", None) is not None
        else None,
        read=bool(json["read"]) if json.get("read", None) is not None else None,
        write_without_response=bool(json["writeWithoutResponse"])
        if json.get("writeWithoutResponse", None) is not None
        else None,
        write=bool(json["write"]) if json.get("write", None) is not None else None,
        notify=bool(json["notify"])
        if json.get("notify", None) is not None
        else None,
        indicate=bool(json["indicate"])
        if json.get("indicate", None) is not None
        else None,
        authenticated_signed_writes=bool(json["authenticatedSignedWrites"])
        if json.get("authenticatedSignedWrites", None) is not None
        else None,
        extended_properties=bool(json["extendedProperties"])
        if json.get("extendedProperties", None) is not None
        else None,
    )

to_json()

Source code in zendriver/cdp/bluetooth_emulation.py 
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    if self.broadcast is not None:
        json["broadcast"] = self.broadcast
    if self.read is not None:
        json["read"] = self.read
    if self.write_without_response is not None:
        json["writeWithoutResponse"] = self.write_without_response
    if self.write is not None:
        json["write"] = self.write
    if self.notify is not None:
        json["notify"] = self.notify
    if self.indicate is not None:
        json["indicate"] = self.indicate
    if self.authenticated_signed_writes is not None:
        json["authenticatedSignedWrites"] = self.authenticated_signed_writes
    if self.extended_properties is not None:
        json["extendedProperties"] = self.extended_properties
    return json

CharacteristicWriteType

Bases: Enum

Indicates the various types of characteristic write.

Source code in zendriver/cdp/bluetooth_emulation.py 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
class CharacteristicWriteType(enum.Enum):
    """
    Indicates the various types of characteristic write.
    """

    WRITE_DEFAULT_DEPRECATED = "write-default-deprecated"
    WRITE_WITH_RESPONSE = "write-with-response"
    WRITE_WITHOUT_RESPONSE = "write-without-response"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> CharacteristicWriteType:
        return cls(json)

WRITE_DEFAULT_DEPRECATED = 'write-default-deprecated' class-attribute instance-attribute

WRITE_WITHOUT_RESPONSE = 'write-without-response' class-attribute instance-attribute

WRITE_WITH_RESPONSE = 'write-with-response' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/bluetooth_emulation.py 
60
61
62
@classmethod
def from_json(cls, json: str) -> CharacteristicWriteType:
    return cls(json)

to_json()

Source code in zendriver/cdp/bluetooth_emulation.py 
57
58
def to_json(self) -> str:
    return self.value

DescriptorOperationReceived dataclass

Event for when a descriptor operation of type to the descriptor respresented by descriptorId happened. data is expected to exist when type is write.

Source code in zendriver/cdp/bluetooth_emulation.py 
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
@event_class("BluetoothEmulation.descriptorOperationReceived")
@dataclass
class DescriptorOperationReceived:
    """
    Event for when a descriptor operation of ``type`` to the descriptor
    respresented by ``descriptorId`` happened. ``data`` is expected to exist when
    ``type`` is write.
    """

    descriptor_id: str
    type_: CharacteristicOperationType
    data: typing.Optional[str]

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> DescriptorOperationReceived:
        return cls(
            descriptor_id=str(json["descriptorId"]),
            type_=CharacteristicOperationType.from_json(json["type"]),
            data=str(json["data"]) if json.get("data", None) is not None else None,
        )

data: typing.Optional[str] instance-attribute

descriptor_id: str instance-attribute

type_: CharacteristicOperationType instance-attribute

__init__(descriptor_id, type_, data)

from_json(json) classmethod

Source code in zendriver/cdp/bluetooth_emulation.py 
647
648
649
650
651
652
653
@classmethod
def from_json(cls, json: T_JSON_DICT) -> DescriptorOperationReceived:
    return cls(
        descriptor_id=str(json["descriptorId"]),
        type_=CharacteristicOperationType.from_json(json["type"]),
        data=str(json["data"]) if json.get("data", None) is not None else None,
    )

DescriptorOperationType

Bases: Enum

Indicates the various types of descriptor operation.

Source code in zendriver/cdp/bluetooth_emulation.py 
83
84
85
86
87
88
89
90
91
92
93
94
95
96
class DescriptorOperationType(enum.Enum):
    """
    Indicates the various types of descriptor operation.
    """

    READ = "read"
    WRITE = "write"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> DescriptorOperationType:
        return cls(json)

READ = 'read' class-attribute instance-attribute

WRITE = 'write' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/bluetooth_emulation.py 
94
95
96
@classmethod
def from_json(cls, json: str) -> DescriptorOperationType:
    return cls(json)

to_json()

Source code in zendriver/cdp/bluetooth_emulation.py 
91
92
def to_json(self) -> str:
    return self.value

GATTOperationType

Bases: Enum

Indicates the various types of GATT event.

Source code in zendriver/cdp/bluetooth_emulation.py 
32
33
34
35
36
37
38
39
40
41
42
43
44
45
class GATTOperationType(enum.Enum):
    """
    Indicates the various types of GATT event.
    """

    CONNECTION = "connection"
    DISCOVERY = "discovery"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> GATTOperationType:
        return cls(json)

CONNECTION = 'connection' class-attribute instance-attribute

DISCOVERY = 'discovery' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/bluetooth_emulation.py 
43
44
45
@classmethod
def from_json(cls, json: str) -> GATTOperationType:
    return cls(json)

to_json()

Source code in zendriver/cdp/bluetooth_emulation.py 
40
41
def to_json(self) -> str:
    return self.value

GattOperationReceived dataclass

Event for when a GATT operation of type to the peripheral with address happened.

Source code in zendriver/cdp/bluetooth_emulation.py 
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
@event_class("BluetoothEmulation.gattOperationReceived")
@dataclass
class GattOperationReceived:
    """
    Event for when a GATT operation of ``type`` to the peripheral with ``address``
    happened.
    """

    address: str
    type_: GATTOperationType

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> GattOperationReceived:
        return cls(
            address=str(json["address"]),
            type_=GATTOperationType.from_json(json["type"]),
        )

address: str instance-attribute

type_: GATTOperationType instance-attribute

__init__(address, type_)

from_json(json) classmethod

Source code in zendriver/cdp/bluetooth_emulation.py 
600
601
602
603
604
605
@classmethod
def from_json(cls, json: T_JSON_DICT) -> GattOperationReceived:
    return cls(
        address=str(json["address"]),
        type_=GATTOperationType.from_json(json["type"]),
    )

ManufacturerData dataclass

Stores the manufacturer data

Source code in zendriver/cdp/bluetooth_emulation.py 
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
@dataclass
class ManufacturerData:
    """
    Stores the manufacturer data
    """

    #: Company identifier
    #: https://bitbucket.org/bluetooth-SIG/public/src/main/assigned_numbers/company_identifiers/company_identifiers.yaml
    #: https://usb.org/developers
    key: int

    #: Manufacturer-specific data (Encoded as a base64 string when passed over JSON)
    data: str

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["key"] = self.key
        json["data"] = self.data
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> ManufacturerData:
        return cls(
            key=int(json["key"]),
            data=str(json["data"]),
        )

data: str instance-attribute

key: int instance-attribute

__init__(key, data)

from_json(json) classmethod

Source code in zendriver/cdp/bluetooth_emulation.py 
119
120
121
122
123
124
@classmethod
def from_json(cls, json: T_JSON_DICT) -> ManufacturerData:
    return cls(
        key=int(json["key"]),
        data=str(json["data"]),
    )

to_json()

Source code in zendriver/cdp/bluetooth_emulation.py 
113
114
115
116
117
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["key"] = self.key
    json["data"] = self.data
    return json

ScanEntry dataclass

Stores the advertisement packet information that is sent by a Bluetooth device.

Source code in zendriver/cdp/bluetooth_emulation.py 
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
@dataclass
class ScanEntry:
    """
    Stores the advertisement packet information that is sent by a Bluetooth device.
    """

    device_address: str

    rssi: int

    scan_record: ScanRecord

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["deviceAddress"] = self.device_address
        json["rssi"] = self.rssi
        json["scanRecord"] = self.scan_record.to_json()
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> ScanEntry:
        return cls(
            device_address=str(json["deviceAddress"]),
            rssi=int(json["rssi"]),
            scan_record=ScanRecord.from_json(json["scanRecord"]),
        )

device_address: str instance-attribute

rssi: int instance-attribute

scan_record: ScanRecord instance-attribute

__init__(device_address, rssi, scan_record)

from_json(json) classmethod

Source code in zendriver/cdp/bluetooth_emulation.py 
201
202
203
204
205
206
207
@classmethod
def from_json(cls, json: T_JSON_DICT) -> ScanEntry:
    return cls(
        device_address=str(json["deviceAddress"]),
        rssi=int(json["rssi"]),
        scan_record=ScanRecord.from_json(json["scanRecord"]),
    )

to_json()

Source code in zendriver/cdp/bluetooth_emulation.py 
194
195
196
197
198
199
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["deviceAddress"] = self.device_address
    json["rssi"] = self.rssi
    json["scanRecord"] = self.scan_record.to_json()
    return json

ScanRecord dataclass

Stores the byte data of the advertisement packet sent by a Bluetooth device.

Source code in zendriver/cdp/bluetooth_emulation.py 
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
@dataclass
class ScanRecord:
    """
    Stores the byte data of the advertisement packet sent by a Bluetooth device.
    """

    name: typing.Optional[str] = None

    uuids: typing.Optional[typing.List[str]] = None

    #: Stores the external appearance description of the device.
    appearance: typing.Optional[int] = None

    #: Stores the transmission power of a broadcasting device.
    tx_power: typing.Optional[int] = None

    #: Key is the company identifier and the value is an array of bytes of
    #: manufacturer specific data.
    manufacturer_data: typing.Optional[typing.List[ManufacturerData]] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        if self.name is not None:
            json["name"] = self.name
        if self.uuids is not None:
            json["uuids"] = [i for i in self.uuids]
        if self.appearance is not None:
            json["appearance"] = self.appearance
        if self.tx_power is not None:
            json["txPower"] = self.tx_power
        if self.manufacturer_data is not None:
            json["manufacturerData"] = [i.to_json() for i in self.manufacturer_data]
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> ScanRecord:
        return cls(
            name=str(json["name"]) if json.get("name", None) is not None else None,
            uuids=[str(i) for i in json["uuids"]]
            if json.get("uuids", None) is not None
            else None,
            appearance=int(json["appearance"])
            if json.get("appearance", None) is not None
            else None,
            tx_power=int(json["txPower"])
            if json.get("txPower", None) is not None
            else None,
            manufacturer_data=[
                ManufacturerData.from_json(i) for i in json["manufacturerData"]
            ]
            if json.get("manufacturerData", None) is not None
            else None,
        )

appearance: typing.Optional[int] = None class-attribute instance-attribute

manufacturer_data: typing.Optional[typing.List[ManufacturerData]] = None class-attribute instance-attribute

name: typing.Optional[str] = None class-attribute instance-attribute

tx_power: typing.Optional[int] = None class-attribute instance-attribute

uuids: typing.Optional[typing.List[str]] = None class-attribute instance-attribute

__init__(name=None, uuids=None, appearance=None, tx_power=None, manufacturer_data=None)

from_json(json) classmethod

Source code in zendriver/cdp/bluetooth_emulation.py 
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
@classmethod
def from_json(cls, json: T_JSON_DICT) -> ScanRecord:
    return cls(
        name=str(json["name"]) if json.get("name", None) is not None else None,
        uuids=[str(i) for i in json["uuids"]]
        if json.get("uuids", None) is not None
        else None,
        appearance=int(json["appearance"])
        if json.get("appearance", None) is not None
        else None,
        tx_power=int(json["txPower"])
        if json.get("txPower", None) is not None
        else None,
        manufacturer_data=[
            ManufacturerData.from_json(i) for i in json["manufacturerData"]
        ]
        if json.get("manufacturerData", None) is not None
        else None,
    )

to_json()

Source code in zendriver/cdp/bluetooth_emulation.py 
147
148
149
150
151
152
153
154
155
156
157
158
159
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    if self.name is not None:
        json["name"] = self.name
    if self.uuids is not None:
        json["uuids"] = [i for i in self.uuids]
    if self.appearance is not None:
        json["appearance"] = self.appearance
    if self.tx_power is not None:
        json["txPower"] = self.tx_power
    if self.manufacturer_data is not None:
        json["manufacturerData"] = [i.to_json() for i in self.manufacturer_data]
    return json

add_characteristic(service_id, characteristic_uuid, properties)

Adds a characteristic with characteristicUuid and properties to the service represented by serviceId.

Parameters:

Name Type Description Default
service_id str
required
characteristic_uuid str
required
properties CharacteristicProperties
required

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, str]

An identifier that uniquely represents this characteristic.
Source code in zendriver/cdp/bluetooth_emulation.py 
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
def add_characteristic(
    service_id: str, characteristic_uuid: str, properties: CharacteristicProperties
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, str]:
    """
    Adds a characteristic with ``characteristicUuid`` and ``properties`` to the
    service represented by ``serviceId``.

    :param service_id:
    :param characteristic_uuid:
    :param properties:
    :returns: An identifier that uniquely represents this characteristic.
    """
    params: T_JSON_DICT = dict()
    params["serviceId"] = service_id
    params["characteristicUuid"] = characteristic_uuid
    params["properties"] = properties.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "BluetoothEmulation.addCharacteristic",
        "params": params,
    }
    json = yield cmd_dict
    return str(json["characteristicId"])

add_descriptor(characteristic_id, descriptor_uuid)

Adds a descriptor with descriptorUuid to the characteristic respresented by characteristicId.

Parameters:

Name Type Description Default
characteristic_id str
required
descriptor_uuid str
required

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, str]

An identifier that uniquely represents this descriptor.
Source code in zendriver/cdp/bluetooth_emulation.py 
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
def add_descriptor(
    characteristic_id: str, descriptor_uuid: str
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, str]:
    """
    Adds a descriptor with ``descriptorUuid`` to the characteristic respresented
    by ``characteristicId``.

    :param characteristic_id:
    :param descriptor_uuid:
    :returns: An identifier that uniquely represents this descriptor.
    """
    params: T_JSON_DICT = dict()
    params["characteristicId"] = characteristic_id
    params["descriptorUuid"] = descriptor_uuid
    cmd_dict: T_JSON_DICT = {
        "method": "BluetoothEmulation.addDescriptor",
        "params": params,
    }
    json = yield cmd_dict
    return str(json["descriptorId"])

add_service(address, service_uuid)

Adds a service with serviceUuid to the peripheral with address.

Parameters:

Name Type Description Default
address str
required
service_uuid str
required

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, str]

An identifier that uniquely represents this service.
Source code in zendriver/cdp/bluetooth_emulation.py 
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
def add_service(
    address: str, service_uuid: str
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, str]:
    """
    Adds a service with ``serviceUuid`` to the peripheral with ``address``.

    :param address:
    :param service_uuid:
    :returns: An identifier that uniquely represents this service.
    """
    params: T_JSON_DICT = dict()
    params["address"] = address
    params["serviceUuid"] = service_uuid
    cmd_dict: T_JSON_DICT = {
        "method": "BluetoothEmulation.addService",
        "params": params,
    }
    json = yield cmd_dict
    return str(json["serviceId"])

disable()

Disable the BluetoothEmulation domain.

Source code in zendriver/cdp/bluetooth_emulation.py 
315
316
317
318
319
320
321
322
def disable() -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Disable the BluetoothEmulation domain.
    """
    cmd_dict: T_JSON_DICT = {
        "method": "BluetoothEmulation.disable",
    }
    json = yield cmd_dict

enable(state, le_supported)

Enable the BluetoothEmulation domain.

Parameters:

Name Type Description Default
state CentralState

State of the simulated central.

 required
le_supported bool

If the simulated central supports low-energy.

 required
Source code in zendriver/cdp/bluetooth_emulation.py 
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
def enable(
    state: CentralState, le_supported: bool
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Enable the BluetoothEmulation domain.

    :param state: State of the simulated central.
    :param le_supported: If the simulated central supports low-energy.
    """
    params: T_JSON_DICT = dict()
    params["state"] = state.to_json()
    params["leSupported"] = le_supported
    cmd_dict: T_JSON_DICT = {
        "method": "BluetoothEmulation.enable",
        "params": params,
    }
    json = yield cmd_dict

remove_characteristic(characteristic_id)

Removes the characteristic respresented by characteristicId from the simulated central.

Parameters:

Name Type Description Default
characteristic_id str
required
Source code in zendriver/cdp/bluetooth_emulation.py 
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
def remove_characteristic(
    characteristic_id: str,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Removes the characteristic respresented by ``characteristicId`` from the
    simulated central.

    :param characteristic_id:
    """
    params: T_JSON_DICT = dict()
    params["characteristicId"] = characteristic_id
    cmd_dict: T_JSON_DICT = {
        "method": "BluetoothEmulation.removeCharacteristic",
        "params": params,
    }
    json = yield cmd_dict

remove_descriptor(descriptor_id)

Removes the descriptor with descriptorId from the simulated central.

Parameters:

Name Type Description Default
descriptor_id str
required
Source code in zendriver/cdp/bluetooth_emulation.py 
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
def remove_descriptor(
    descriptor_id: str,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Removes the descriptor with ``descriptorId`` from the simulated central.

    :param descriptor_id:
    """
    params: T_JSON_DICT = dict()
    params["descriptorId"] = descriptor_id
    cmd_dict: T_JSON_DICT = {
        "method": "BluetoothEmulation.removeDescriptor",
        "params": params,
    }
    json = yield cmd_dict

remove_service(service_id)

Removes the service respresented by serviceId from the simulated central.

Parameters:

Name Type Description Default
service_id str
required
Source code in zendriver/cdp/bluetooth_emulation.py 
476
477
478
479
480
481
482
483
484
485
486
487
488
def remove_service(service_id: str) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Removes the service respresented by ``serviceId`` from the simulated central.

    :param service_id:
    """
    params: T_JSON_DICT = dict()
    params["serviceId"] = service_id
    cmd_dict: T_JSON_DICT = {
        "method": "BluetoothEmulation.removeService",
        "params": params,
    }
    json = yield cmd_dict

set_simulated_central_state(state)

Set the state of the simulated central.

Parameters:

Name Type Description Default
state CentralState

State of the simulated central.

 required
Source code in zendriver/cdp/bluetooth_emulation.py 
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
def set_simulated_central_state(
    state: CentralState,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Set the state of the simulated central.

    :param state: State of the simulated central.
    """
    params: T_JSON_DICT = dict()
    params["state"] = state.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "BluetoothEmulation.setSimulatedCentralState",
        "params": params,
    }
    json = yield cmd_dict

simulate_advertisement(entry)

Simulates an advertisement packet described in entry being received by the central.

Parameters:

Name Type Description Default
entry ScanEntry
required
Source code in zendriver/cdp/bluetooth_emulation.py 
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
def simulate_advertisement(
    entry: ScanEntry,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Simulates an advertisement packet described in ``entry`` being received by
    the central.

    :param entry:
    """
    params: T_JSON_DICT = dict()
    params["entry"] = entry.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "BluetoothEmulation.simulateAdvertisement",
        "params": params,
    }
    json = yield cmd_dict

simulate_characteristic_operation_response(characteristic_id, type_, code, data=None)

Simulates the response from the characteristic with characteristicId for a characteristic operation of type. The code value follows the Error Codes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response. The data is expected to exist when simulating a successful read operation response.

Parameters:

Name Type Description Default
characteristic_id str
required
type_ CharacteristicOperationType
required
code int
required
data Optional[str]

(Optional)

 None
Source code in zendriver/cdp/bluetooth_emulation.py 
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
def simulate_characteristic_operation_response(
    characteristic_id: str,
    type_: CharacteristicOperationType,
    code: int,
    data: typing.Optional[str] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Simulates the response from the characteristic with ``characteristicId`` for a
    characteristic operation of ``type``. The ``code`` value follows the Error
    Codes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response.
    The ``data`` is expected to exist when simulating a successful read operation
    response.

    :param characteristic_id:
    :param type_:
    :param code:
    :param data: *(Optional)*
    """
    params: T_JSON_DICT = dict()
    params["characteristicId"] = characteristic_id
    params["type"] = type_.to_json()
    params["code"] = code
    if data is not None:
        params["data"] = data
    cmd_dict: T_JSON_DICT = {
        "method": "BluetoothEmulation.simulateCharacteristicOperationResponse",
        "params": params,
    }
    json = yield cmd_dict

simulate_descriptor_operation_response(descriptor_id, type_, code, data=None)

Simulates the response from the descriptor with descriptorId for a descriptor operation of type. The code value follows the Error Codes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response. The data is expected to exist when simulating a successful read operation response.

Parameters:

Name Type Description Default
descriptor_id str
required
type_ DescriptorOperationType
required
code int
required
data Optional[str]

(Optional)

 None
Source code in zendriver/cdp/bluetooth_emulation.py 
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
def simulate_descriptor_operation_response(
    descriptor_id: str,
    type_: DescriptorOperationType,
    code: int,
    data: typing.Optional[str] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Simulates the response from the descriptor with ``descriptorId`` for a
    descriptor operation of ``type``. The ``code`` value follows the Error
    Codes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response.
    The ``data`` is expected to exist when simulating a successful read operation
    response.

    :param descriptor_id:
    :param type_:
    :param code:
    :param data: *(Optional)*
    """
    params: T_JSON_DICT = dict()
    params["descriptorId"] = descriptor_id
    params["type"] = type_.to_json()
    params["code"] = code
    if data is not None:
        params["data"] = data
    cmd_dict: T_JSON_DICT = {
        "method": "BluetoothEmulation.simulateDescriptorOperationResponse",
        "params": params,
    }
    json = yield cmd_dict

simulate_gatt_disconnection(address)

Simulates a GATT disconnection from the peripheral with address.

Parameters:

Name Type Description Default
address str
required
Source code in zendriver/cdp/bluetooth_emulation.py 
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
def simulate_gatt_disconnection(
    address: str,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Simulates a GATT disconnection from the peripheral with ``address``.

    :param address:
    """
    params: T_JSON_DICT = dict()
    params["address"] = address
    cmd_dict: T_JSON_DICT = {
        "method": "BluetoothEmulation.simulateGATTDisconnection",
        "params": params,
    }
    json = yield cmd_dict

simulate_gatt_operation_response(address, type_, code)

Simulates the response code from the peripheral with address for a GATT operation of type. The code value follows the HCI Error Codes from Bluetooth Core Specification Vol 2 Part D 1.3 List Of Error Codes.

Parameters:

Name Type Description Default
address str
required
type_ GATTOperationType
required
code int
required
Source code in zendriver/cdp/bluetooth_emulation.py 
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
def simulate_gatt_operation_response(
    address: str, type_: GATTOperationType, code: int
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Simulates the response code from the peripheral with ``address`` for a
    GATT operation of ``type``. The ``code`` value follows the HCI Error Codes from
    Bluetooth Core Specification Vol 2 Part D 1.3 List Of Error Codes.

    :param address:
    :param type_:
    :param code:
    """
    params: T_JSON_DICT = dict()
    params["address"] = address
    params["type"] = type_.to_json()
    params["code"] = code
    cmd_dict: T_JSON_DICT = {
        "method": "BluetoothEmulation.simulateGATTOperationResponse",
        "params": params,
    }
    json = yield cmd_dict

simulate_preconnected_peripheral(address, name, manufacturer_data, known_service_uuids)

Simulates a peripheral with address, name and knownServiceUuids that has already been connected to the system.

Parameters:

Name Type Description Default
address str
required
name str
required
manufacturer_data List[ManufacturerData]
required
known_service_uuids List[str]
required
Source code in zendriver/cdp/bluetooth_emulation.py 
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
def simulate_preconnected_peripheral(
    address: str,
    name: str,
    manufacturer_data: typing.List[ManufacturerData],
    known_service_uuids: typing.List[str],
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Simulates a peripheral with ``address``, ``name`` and ``knownServiceUuids``
    that has already been connected to the system.

    :param address:
    :param name:
    :param manufacturer_data:
    :param known_service_uuids:
    """
    params: T_JSON_DICT = dict()
    params["address"] = address
    params["name"] = name
    params["manufacturerData"] = [i.to_json() for i in manufacturer_data]
    params["knownServiceUuids"] = [i for i in known_service_uuids]
    cmd_dict: T_JSON_DICT = {
        "method": "BluetoothEmulation.simulatePreconnectedPeripheral",
        "params": params,
    }
    json = yield cmd_dict