Catch a reconnect event

[natdevko]

I have a project based on GUI, that interacts with BLE device (device is not commercially avaiable). I use mainly Windows 10, but it works with Windows 11 too. I connect and disconnect with device with async functions:

async def single_connect(self, address):
    single_client = BleakClient(address,
                                disconnected_callback=self._disconnect_callback)
    if single_client is not None:
        if not single_client.is_connected:
            try:
                await single_client.connect()
            except (ValueError, Exception) as e:
                logger.error("Can't connect: %s, reason: %s", address, e)
                return [None, None]
            else:
                if single_client.is_connected:
                    dev_class = await self._handler_single_connect(single_client)
                    return single_client, dev_class
                if not single_client.is_connected:
                    logger.error('Failed to connect')
                    return [None, None]
        if single_client.is_connected:
            logger.warning('Client already connected')

async def _handler_disconnecting(self, device_class, single_client):
    try:
        # here is not relevant and private code

        if single_client.is_connected:
            if device_class is not None:
                logger.debug("Disconnecting device, %s", datetime.now())
                device_class.stop_all_notifies()
                await single_client.disconnect()
                while single_client.is_connected:
                    continue
                logger.debug('Disconnected single client: %s',
                             str(single_client.address))
        else:
            # device_class.stop_all_notifies()
            self._disconnect_callback(single_client)
            logger.warning("Already disconnected: %s", single_client.address)
    except (ValueError, Exception) as e:
        logger.error('Error disconnecting to device, %s', e)
        raise Exception(e) from e

It works most of the time. Problem raises when:
a) device disconnects and connects again (this happens on lower levels of software than I reach)
b) device reset itself

After those, even though low-level code does reconnecting, my functions and Bleak objects are "dead". I canot send or receive GATT service and sometimes I get WinError -2147467260. This is a huge problem, because one of functions is reset after sending GATT service. It means, that ideally, after reset everything should get "reconnected". The device gets reconnected not openly (by Bleak or by Windows driver, I do not know). How can I get new object after this hiden reconnect?

I do know, which device did reset (by MAC address), but I do not know how to invoke this hidden new Bleak (?) client. If I create client with BleakClient(address, disconnected_callback=self._disconnect_callback) it is not the same client object, that got reconnected.

I do know that in different languages and on Android you can easily get this kind of "reconnect" event or control it. I do want to know how to do this with Bleak library on Windows. And I do not want to do disconnect and connect on my own, as it takes time and is something completely different for my application than auto-reconnect. I assume there is a some kind of data container in Bleak library, where all clients reside. From this data container I could receive proper, new object. Without proper client object I cannot use my app further. But I do not know what or where is it (or how to access it).

Anyone can give my any tip?

[tcamise-gpsw]

I also have basically this exact same problem and have no idea how to solve it 😢

[dlech]

90% of the time when there is an error from the OS-specific APIs, logging Bluetooth packets is the best way to understand what is happening.

https://bleak.readthedocs.io/en/latest/troubleshooting.html#capture-bluetooth-traffic

[tcamise-gpsw]

So here's the scenario which I'm not sure is solvable with bleak. Or at least I'm unaware of how bleak manages reconnects.

1. I connect via bleak (on Windows) to BLE peripheral device
2. Peripheral device silently disconnects. Basically it turns off for a long enough time to trigger the supervision timeout
3. I receive disconnect event from bleak

Then the following race condition occurs:

Path 1 is:

1. Peripheral device powers back on and becomes connectable
2. Windows OS automatically reconnects to peripheral device. Or is this actually bleak reconnecting?

Path 2:

1. I have started to scan (via bleak) and reconnect to the device
2. The reconnection fails since the device was already connected to

I could solve this if either:

• the automatic reconnect did not happen on path 1
• I could receive a reconnection event and reuse the client on Path 2 instead of reconnecting

[dlech]

2. Windows OS automatically reconnects to peripheral device. Or is this actually bleak reconnecting?

Bleak doesn't attempt to reconnect, so this would be Windows doing it. In theory, if we get the disconnect event in Bleak, we should be ending the gatt session that we have requested. In theory, if there are no existing gatt sessions, the Windows should not have a reason to reconnect. But Windows is just a block box to us, so hard to say what the actual algorithm is. Depending on the type of device and if it is paired or not, other parts of the Windows OS might also influence if it tries to reconnect or not.

• could receive a reconnection event and reuse the client on Path 2 instead of reconnecting

Hmm... this is tricky. Maybe something that could be solved by solving #367.

[tcamise-gpsw]

Yep #367 is exactly my use case. I'm confused how more people aren't running into this.