def __init__(self, ble_device, peer, read_write_manager, uuid, properties,
declaration_handle, value_handle, cccd_handle=None):
"""
:type ble_device: blatann.BleDevice
:type peer: blatann.peer.Peripheral
:type read_write_manager: _ReadWriteManager
:type uuid: blatann.uuid.Uuid
:type properties: gatt.CharacteristicProperties
:param declaration_handle:
:param value_handle:
:param cccd_handle:
"""
super(GattcCharacteristic, self).__init__(ble_device, peer, uuid, properties)
self.declaration_handle = declaration_handle
self.value_handle = value_handle
self.cccd_handle = cccd_handle
self._manager = read_write_manager
self._value = b""
self._on_notification_event = EventSource("On Notification", logger)
self._on_read_complete_event = EventSource("On Read Complete", logger)
self._on_write_complete_event = EventSource("Write Complete", logger)
self._on_cccd_write_complete_event = EventSource("CCCD Write Complete", logger)
self.peer.driver_event_subscribe(self._on_indication_notification, nrf_events.GattcEvtHvx)
self._manager.on_write_complete.register(self._write_complete)
self._manager.on_read_complete.register(self._read_complete)
def __init__(self,
ble_device,
role,
connection_params=DEFAULT_CONNECTION_PARAMS,
security_params=DEFAULT_SECURITY_PARAMS):
"""
:type ble_device: blatann.device.BleDevice
"""
self._ble_device = ble_device
self._role = role
self._ideal_connection_params = connection_params
self._current_connection_params = DEFAULT_CONNECTION_PARAMS
self.conn_handle = BLE_CONN_HANDLE_INVALID
self.peer_address = "",
self.connection_state = PeerState.DISCONNECTED
self._on_connect = EventSource("On Connect", logger)
self._on_disconnect = EventSource("On Disconnect", logger)
self._on_mtu_exchange_complete = EventSource(
"On MTU Exchange Complete", logger)
self._on_mtu_size_updated = EventSource("On MTU Size Updated", logger)
self._mtu_size = MTU_SIZE_DEFAULT
self._preferred_mtu_size = MTU_SIZE_DEFAULT
self._negotiated_mtu_size = None
self._connection_based_driver_event_handlers = {}
self._connection_handler_lock = threading.Lock()
self.security = smp.SecurityManager(self._ble_device, self,
security_params)
def __init__(self,
ble_device: BleDevice,
peer: Peer,
parent: GattsCharacteristic,
uuid: Uuid,
handle: int,
properties: GattsAttributeProperties,
initial_value=b"",
string_encoding="utf8"):
super(GattsAttribute, self).__init__(uuid, handle, initial_value,
string_encoding)
self._ble_device = ble_device
self._peer = peer
self._parent = parent
self._properties = properties
# Events
self._on_write = EventSource("Write Event", logger)
self._on_read = EventSource("Read Event", logger)
# Subscribed events
if properties.write:
self._ble_device.ble_driver.event_subscribe(
self._on_gatts_write, nrf_events.GattsEvtWrite)
if properties.read_auth or properties.write_auth:
self._ble_device.ble_driver.event_subscribe(
self._on_rw_auth_request,
nrf_events.GattsEvtReadWriteAuthorizeRequest)
# Internal state tracking stuff
self._write_queued = False
self._read_in_process = False
self._queued_write_chunks = []
def __init__(self,
ble_device,
peer,
uuid: Uuid,
properties: gatt.CharacteristicProperties,
decl_attr: GattcAttribute,
value_attr: GattcAttribute,
cccd_attr: GattcAttribute = None,
attributes: List[GattcAttribute] = None):
super(GattcCharacteristic, self).__init__(ble_device, peer, uuid,
properties)
self._decl_attr = decl_attr
self._value_attr = value_attr
self._cccd_attr = cccd_attr
self._on_notification_event = EventSource("On Notification", logger)
self._attributes = tuple(sorted(attributes,
key=lambda d: d.handle)) or ()
self.peer = peer
self._on_read_complete_event = EventSource("On Read Complete", logger)
self._on_write_complete_event = EventSource("Write Complete", logger)
self._on_cccd_write_complete_event = EventSource(
"CCCD Write Complete", logger)
self._value_attr.on_read_complete.register(self._read_complete)
self._value_attr.on_write_complete.register(self._write_complete)
if self._cccd_attr:
self._cccd_attr.on_write_complete.register(
self._cccd_write_complete)
self.peer.driver_event_subscribe(self._on_indication_notification,
nrf_events.GattcEvtHvx)
def __init__(self, gattc_service):
"""
:type gattc_service: blatann.gatt.gattc.GattcService
"""
self._service = gattc_service
self._current_time_char = gattc_service.find_characteristic(
CURRENT_TIME_CHARACTERISTIC_UUID)
self._local_time_info_char = gattc_service.find_characteristic(
LOCAL_TIME_INFO_CHARACTERISTIC_UUID)
self._ref_info_char = gattc_service.find_characteristic(
REFERENCE_INFO_CHARACTERISTIC_UUID)
self._on_current_time_updated_event = EventSource(
"Current Time Update Event")
self._on_local_time_info_updated_event = EventSource(
"Local Time Info Update Event")
self._on_reference_info_updated_event = EventSource(
"Reference Info Update Event")
self._current_time_dispatcher = DecodedReadWriteEventDispatcher(
self, CurrentTime, self._on_current_time_updated_event, logger)
self._local_time_dispatcher = DecodedReadWriteEventDispatcher(
self, LocalTimeInfo, self._on_local_time_info_updated_event,
logger)
self._ref_time_dispatcher = DecodedReadWriteEventDispatcher(
self, ReferenceTimeInfo, self._on_reference_info_updated_event,
logger)
def __init__(self, uuid: Uuid, handle: int, read_write_manager: GattcOperationManager,
initial_value=b"", string_encoding="utf8"):
super(GattcAttribute, self).__init__(uuid, handle, initial_value, string_encoding)
self._manager = read_write_manager
self._on_read_complete_event = EventSource(f"[{handle}/{uuid}] On Read Complete", logger)
self._on_write_complete_event = EventSource(f"[{handle}/{uuid}] On Write Complete", logger)
def __init__(self, ble_device, peer, security_parameters):
"""
:type ble_device: blatann.BleDevice
:type peer: blatann.peer.Peer
:type security_parameters: SecurityParameters
"""
self.ble_device = ble_device
self.peer = peer
self.security_params = security_parameters
self._pairing_in_process = False
self._initiated_encryption = False
self._is_previously_bonded_device = False
self._on_authentication_complete_event = EventSource(
"On Authentication Complete", logger)
self._on_passkey_display_event = EventSource("On Passkey Display",
logger)
self._on_passkey_entry_event = EventSource("On Passkey Entry", logger)
self._on_security_level_changed_event = EventSource(
"Security Level Changed", logger)
self.peer.on_connect.register(self._on_peer_connected)
self._auth_key_resolve_thread = threading.Thread()
self.keyset = nrf_types.BLEGapSecKeyset()
self.bond_db_entry = None
self._security_level = SecurityLevel.NO_ACCESS
self._private_key = smp_crypto.lesc_generate_private_key()
self._public_key = self._private_key.public_key()
self.keyset.own_keys.public_key.key = smp_crypto.lesc_pubkey_to_raw(
self._public_key)
def __init__(self, ble_device, peer, uuid, properties, notification_manager, value="", prefer_indications=True):
"""
:param ble_device:
:param peer:
:param uuid:
:type properties: gatt.GattsCharacteristicProperties
:type notification_manager: _NotificationManager
:param value:
:param prefer_indications:
"""
super(GattsCharacteristic, self).__init__(ble_device, peer, uuid, properties)
self._value = value
self.prefer_indications = prefer_indications
self._notification_manager = notification_manager
# Events
self._on_write = EventSource("Write Event", logger)
self._on_read = EventSource("Read Event", logger)
self._on_sub_change = EventSource("Subscription Change Event", logger)
self._on_notify_complete = EventSource("Notification Complete Event", logger)
# Subscribed events
self.ble_device.ble_driver.event_subscribe(self._on_gatts_write, nrf_events.GattsEvtWrite)
self.ble_device.ble_driver.event_subscribe(self._on_rw_auth_request, nrf_events.GattsEvtReadWriteAuthorizeRequest)
# Internal state tracking stuff
self._write_queued = False
self._read_in_process = False
self._queued_write_chunks = []
self.peer.on_disconnect.register(self._on_disconnect)
def __init__(self, ble_device: BleDevice,
peer: Peer,
uuid: Uuid,
properties: GattsCharacteristicProperties,
value_handle: int, cccd_handle: int, sccd_handle: int, user_desc_handle: int,
notification_manager: GattsOperationManager,
value=b"",
prefer_indications=True,
string_encoding="utf8"):
super(GattsCharacteristic, self).__init__(ble_device, peer, uuid, properties, string_encoding)
self._value = value
self.prefer_indications = prefer_indications
self._notification_manager = notification_manager
value_attr_props = GattsAttributeProperties(properties.read, properties.write or properties.write_no_response,
properties.security_level, properties.max_len, properties.variable_length,
True, True)
self._value_attr = GattsAttribute(self.ble_device, self.peer, self, uuid,
value_handle, value_attr_props, value, string_encoding)
self._attrs: List[GattsAttribute] = [self._value_attr]
self._presentation_format = properties.presentation
if cccd_handle != nrf_types.BLE_GATT_HANDLE_INVALID:
cccd_props = GattsAttributeProperties(True, True, gatt.SecurityLevel.OPEN, 2, False, False, False)
self._cccd_attr = GattsAttribute(self.ble_device, self.peer, self, DescriptorUuid.cccd,
cccd_handle, cccd_props, b"\x00\x00")
self._attrs.append(self._cccd_attr)
else:
self._cccd_attr = None
if user_desc_handle != nrf_types.BLE_GATT_HANDLE_INVALID:
self._user_desc_attr = GattsAttribute(self.ble_device, self.peer, self, DescriptorUuid.user_description, user_desc_handle,
properties.user_description, properties.user_description.value, string_encoding)
self._attrs.append(self._user_desc_attr)
else:
self._user_desc_attr = None
if sccd_handle != nrf_types.BLE_GATT_HANDLE_INVALID:
sccd_props = GattsAttributeProperties(True, True, gatt.SecurityLevel.OPEN, 2, False, False, False)
self._sccd_attr = GattsAttribute(self.ble_device, self.peer, self, DescriptorUuid.sccd,
sccd_handle, sccd_props, b"\x00\x00")
self._attrs.append(self._sccd_attr)
# Events
self._on_write = EventSource("Write Event", logger)
self._on_read = EventSource("Read Event", logger)
self._on_sub_change = EventSource("Subscription Change Event", logger)
self._on_notify_complete = EventSource("Notification Complete Event", logger)
# Subscribed events
self.peer.on_disconnect.register(self._on_disconnect)
self._value_attr.on_read.register(self._on_value_read)
self._value_attr.on_write.register(self._on_value_write)
if self._cccd_attr:
self._cccd_attr.on_write.register(self._on_cccd_write)
def __init__(self, ble_device, peer):
"""
:type ble_device: blatann.device.BleDevice
:type peer: blatann.peer.Peer
"""
self.ble_device = ble_device
self.peer = peer
self._on_discovery_complete = EventSource("Service Discovery Complete", logger)
self._on_database_discovery_complete = EventSource("Service Discovery Complete", logger)
self._state = _DiscoveryState()
self._service_discoverer = _ServiceDiscoverer(ble_device, peer)
self._characteristic_discoverer = _CharacteristicDiscoverer(ble_device, peer)
self._descriptor_discoverer = _DescriptorDiscoverer(ble_device, peer)
def __init__(self, reader: GattcReader, writer: GattcWriter):
super(_ReadWriteManager, self).__init__()
self._reader = reader
self._writer = writer
self._reader.peer.on_disconnect.register(self._on_disconnect)
self._cur_read_task = None
self._cur_write_task = None
self.on_read_complete = EventSource("Gattc Read Complete", logger)
self.on_write_complete = EventSource("Gattc Write Complete", logger)
self._reader.on_read_complete.register(self._read_complete)
self._writer.on_write_complete.register(self._write_complete)
self._reader.peer.driver_event_subscribe(self._on_timeout,
nrf_events.GattcEvtTimeout)
def __init__(self, reader, writer):
"""
:type reader: GattcReader
:type writer: GattcWriter
"""
super(_ReadWriteManager, self).__init__()
self._reader = reader
self._writer = writer
self._reader.peer.on_disconnect.register(self._on_disconnect)
self._cur_read_task = None
self._cur_write_task = None
self.on_read_complete = EventSource("Gattc Read Complete", logger)
self.on_write_complete = EventSource("Gattc Write Complete", logger)
self._reader.on_read_complete.register(self._read_complete)
self._writer.on_write_complete.register(self._write_complete)
def __init__(self, gattc_service):
"""
:type gattc_service: blatann.gatt.gattc.GattcService
"""
self._service = gattc_service
self._batt_characteristic = gattc_service.find_characteristic(BATTERY_LEVEL_CHARACTERISTIC_UUID)
self._on_battery_level_updated_event = EventSource("Battery Level Update Event")
def __init__(self, ble_device):
"""
:type ble_device: blatann.device.BleDevice
"""
self.ble_device = ble_device
self._default_scan_params = ScanParameters(200, 150, 10)
self._is_scanning = False
ble_device.ble_driver.event_subscribe(self._on_adv_report,
nrf_events.GapEvtAdvReport)
ble_device.ble_driver.event_subscribe(self._on_timeout_event,
nrf_events.GapEvtTimeout)
self.scan_report = ScanReportCollection()
self._on_scan_received: EventSource[Scanner, ScanReport] = EventSource(
"On Scan Received", logger)
self._on_scan_timeout: EventSource[
Scanner, ScanReportCollection] = EventSource("On Scan Timeout")
def __init__(self, ble_device, peer, security_parameters):
"""
:type ble_device: blatann.BleDevice
:type peer: blatann.peer.Peer
:type security_parameters: SecurityParameters
"""
self.ble_device = ble_device
self.peer = peer
self.security_params = security_parameters
self._busy = False
self._on_authentication_complete_event = EventSource(
"On Authentication Complete", logger)
self._on_passkey_display_event = EventSource("On Passkey Display",
logger)
self._on_passkey_entry_event = EventSource("On Passkey Entry", logger)
self.peer.on_connect.register(self._on_peer_connected)
self._auth_key_resolve_thread = threading.Thread()
def __init__(self, name, ble_device, peer):
"""
:type ble_device: blatann.BleDevice
:type peer: blatann.peer.Peer
"""
self.ble_device = ble_device
self.peer = peer
self._state = _DiscoveryState()
self._on_complete_event = EventSource("{} Complete".format(name), logger)
def __init__(self, service, is_writable=False,
enable_local_time_info_char=False, enable_ref_time_info_char=False):
"""
:type service: GattsService
:param is_writable:
:param enable_local_time_info_char:
:param enable_ref_time_info_char:
"""
self._service = service
self._is_writable = is_writable
self._has_local_time_info = enable_local_time_info_char
self._has_ref_time_info = enable_ref_time_info_char
self._current_time_read_callback = self._on_characteristic_read_auto
self._time_delta = datetime.timedelta()
self._on_current_time_write_event = EventSource("Current Time Write Event")
self._on_local_time_info_write_event = EventSource("Local Time Info Write Event")
self._current_time_dispatcher = DecodedReadWriteEventDispatcher(self, CurrentTime,
self._on_current_time_write_event, logger)
self._local_time_dispatcher = DecodedReadWriteEventDispatcher(self, LocalTimeInfo,
self._on_local_time_info_write_event, logger)
cur_time_char_props = GattsCharacteristicProperties(read=True, notify=True, write=is_writable,
variable_length=False, max_length=CurrentTime.encoded_size())
self._cur_time_char = service.add_characteristic(CURRENT_TIME_CHARACTERISTIC_UUID, cur_time_char_props)
self._cur_time_char.on_read.register(self._on_current_time_read)
self._cur_time_char.on_write.register(self._current_time_dispatcher)
if enable_local_time_info_char:
local_time_props = GattsCharacteristicProperties(read=True, notify=True, write=is_writable,
variable_length=False, max_length=LocalTimeInfo.encoded_size())
self._local_time_char = service.add_characteristic(LOCAL_TIME_INFO_CHARACTERISTIC_UUID, local_time_props)
self.set_local_time_info()
self._local_time_char.on_write.register(self._local_time_dispatcher)
if enable_ref_time_info_char:
ref_time_props = GattsCharacteristicProperties(read=True, notify=False, write=False,
variable_length=False, max_length=ReferenceTimeInfo.encoded_size())
self._ref_time_char = service.add_characteristic(REFERENCE_INFO_CHARACTERISTIC_UUID, ref_time_props)
self.set_reference_info()
self.set_time(datetime.datetime.utcfromtimestamp(0))
def __init__(self,
ble_device,
role,
connection_params=DEFAULT_CONNECTION_PARAMS,
security_params=DEFAULT_SECURITY_PARAMS):
"""
:type ble_device: blatann.device.BleDevice
"""
self._ble_device = ble_device
self._role = role
self._ideal_connection_params = connection_params
self._current_connection_params = DEFAULT_CONNECTION_PARAMS
self.conn_handle = BLE_CONN_HANDLE_INVALID
self.peer_address = "",
self.connection_state = PeerState.DISCONNECTED
self._on_connect = EventSource("On Connect", logger)
self._on_disconnect = EventSource("On Disconnect", logger)
self._mtu_size = 23 # TODO: MTU Exchange procedure
self._connection_based_driver_event_handlers = {}
self._connection_handler_lock = threading.Lock()
self.security = smp.SecurityManager(self._ble_device, self,
security_params)
def __init__(self, ble_device, peer):
"""
:type ble_device: blatann.device.BleDevice
:type peer: blatann.peer.Peer
"""
self.ble_device = ble_device
self.peer = peer
self._on_read_complete_event = EventSource("On Read Complete", logger)
self._busy = False
self._data = bytearray()
self._handle = 0x0000
self._offset = 0
self.peer.driver_event_subscribe(self._on_read_response, nrf_events.GattcEvtReadResponse)
def __init__(self, ble_device, peer):
"""
:type ble_device: blatann.device.BleDevice
:type peer: blatann.peer.Peer
"""
self.ble_device = ble_device
self.peer = peer
self._on_write_complete = EventSource("On Write Complete", logger)
self._busy = False
self._data = ""
self._handle = 0x0000
self._offset = 0
self.peer.driver_event_subscribe(self._on_write_response, nrf_events.GattcEvtWriteResponse)
self._len_bytes_written = 0
def __init__(self, ble_device, client):
"""
:type ble_device: blatann.device.BleDevice
:type client: blatann.peer.Client
"""
self.ble_device = ble_device
self.advertising = False
self._auto_restart = False
self.client = client
self.ble_device.ble_driver.event_subscribe(self._handle_adv_timeout, nrf_events.GapEvtTimeout)
self.ble_device.ble_driver.event_subscribe(self._handle_disconnect, nrf_events.GapEvtDisconnected)
self._on_advertising_timeout = EventSource("Advertising Timeout", logger)
self._advertise_interval = 100
self._timeout = self.ADVERTISE_FOREVER
self._advertise_mode = AdvertisingMode.connectable_undirected
def __init__(self,
ble_device,
role,
connection_params=DEFAULT_CONNECTION_PARAMS,
security_params=DEFAULT_SECURITY_PARAMS,
name="",
write_no_resp_queue_size=1):
"""
:type ble_device: blatann.device.BleDevice
"""
self._ble_device = ble_device
self._role = role
self._name = name
self._preferred_connection_params = connection_params
self._current_connection_params = ActiveConnectionParameters(
connection_params)
self.conn_handle = BLE_CONN_HANDLE_INVALID
self.peer_address = "",
self.connection_state = PeerState.DISCONNECTED
self._on_connect = EventSource("On Connect", logger)
self._on_disconnect = EventSource("On Disconnect", logger)
self._on_mtu_exchange_complete = EventSource(
"On MTU Exchange Complete", logger)
self._on_mtu_size_updated = EventSource("On MTU Size Updated", logger)
self._on_data_length_updated = EventSource("On Data Length Updated",
logger)
self._on_phy_updated = EventSource("On Phy Updated", logger)
self._mtu_size = MTU_SIZE_DEFAULT
self._preferred_mtu_size = MTU_SIZE_DEFAULT
self._negotiated_mtu_size = None
self._preferred_phy = Phy.auto
self._current_phy = Phy.one_mbps
self._disconnection_reason = nrf_events.BLEHci.local_host_terminated_connection
self._connection_based_driver_event_handlers = {}
self._connection_handler_lock = threading.Lock()
self.security = smp.SecurityManager(self._ble_device, self,
security_params)
self._db = gattc.GattcDatabase(ble_device, self,
write_no_resp_queue_size)
self._discoverer = service_discovery.DatabaseDiscoverer(
ble_device, self)
def __init__(self, service, uuid, data_class):
super(_DisClientCharacteristic, self).__init__(service, uuid,
data_class)
self._char = service.find_characteristic(uuid)
self._on_read_complete_event = EventSource(
"Char {} Read Complete".format(self.uuid))
