GUI is freezing with Bleak, Pyqt5, asyncio and qasync when opencv is recording with asyncio at the same time

[ivanjimenez]

• bleak version: 0.14.3
• Python version: 3.9
• Operating System: Windows 10
• BlueZ version (bluetoothctl -v) in case of Linux:

Description

I have a GUI application with Pyqt5 and bleak. I use qasync module to use asyncio and PyQt. All seems work fine, the app have scan, connect, start_capture, pause_capture buttons with async methods. The app has a button in order to record video at the sametime with async functions (also tested with QThreads). But when I start de video capture then GUI is not responding

I have used QThreads and after async functions in Camera module. I don't know if is better do tasks to asyncio (ensure_future) or using only async/await methods.

What I Did

#### Class QBleakClient as interface
@dataclass
class QBleakClient(QObject):
    device: BLEDevice

    messageChanged = pyqtSignal(bytes)
    
    def __post_init__(self):
        super().__init__()
    

    @cached_property
    def client(self) -> BleakClient:
        return BleakClient(self.device, disconnected_callback=self._handle_disconnect,  use_cached=False)

    async def start(self):
        try:
            await self.client.connect()
            await self.client.start_notify(UART_TX_CHAR_UUID, self._handle_read)
        except asyncio.TimeoutError:
            pass

    async def stop(self):
        #await self.client.unpair()
        await self.client.disconnect()

    async def unpairing(self):
        await self.client.unpair()

    async def pause(self):
        await self.client.write_gatt_char(UART_RX_CHAR_UUID, bytearray(...))

    def getAddress(self) -> str:
        return self.client.address

    async def write(self):

        await self.client.write_gatt_char(UART_RX_CHAR_UUID, bytearray(...))
        await self.client.write_gatt_char(UART_RX_CHAR_UUID, bytearray(...))

    def _handle_disconnect(self, str):
        print("Device was disconnected, goodbye.")
        # cancelling all tasks effectively ends the program

        for task in asyncio.all_tasks():
            task.cancel()


    def TreatData(self, data):
       
        # Decode data


    def _handle_read(self, _: int, data: bytearray) -> None:

        global imu_count
        msg = self.TreatData(data)  # data decoded
        self.messageChanged.emit(msg))

# UI
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.list_devices = []  # list of scanned devices (mac list)
        self.qclients = []  # list of QBleakClient objects



    ### Layout with buttons, I put only the slot and methods.

    @qasync.asyncSlot()
    async def button_scanning(self):
       
       
        scanner = BleakScanner()

        self.devices = await scanner.discover(timeout=5.0)

        for device in enumerate(self.devices):
            
            self.list_devices.append(device)
    
    def button_connect(self):
            for device in self.list_devices:
               if isinstance(device, BLEDevice):
                     self.qclients.append(QBleakClient(device))  # Add QBleakClient object

            for d in self.qclients:
                asyncio.ensure_future(d.start())  # can use async/await with same result. I call async task 
                                                  #   into sync method

     def button_pause(self):
            # Method for pause sensor
            for d in self.qclients:
                asyncio.ensure_future(d.pause())

      def button_disconnect(self):

        for d in self.qclients:
                asyncio.ensure_future(d.stop())


       def addRemoveCamera(self):
           #Only start camera capture
      
           asyncio.ensure_future(CameraControls().do_test())

## Module to use opencv async
## CameraControls.py

from cv2 import cv2 as cv
import requests
import time
import asyncio
import concurrent.futures
from datetime import datetime
# from tmp.room import room

cam = cv.VideoCapture(1)  # 0 -> index of camera
width = int(cam.get(cv.CAP_PROP_FRAME_WIDTH) + 0.5)
height = int(cam.get(cv.CAP_PROP_FRAME_HEIGHT) + 0.5)
size = (width, height)
# Define the codec and create VideoWriter object
fourcc = cv.VideoWriter_fourcc(*'XVID')
# out = cv.VideoWriter(f'{room}.avi', fourcc, 10.0, size, 1)
out = cv.VideoWriter(f'output.avi', fourcc, 30.0, size, 1)


class CameraControls(object):
    def __init__(self):
        self.flag = True

    def recording(self):
        while True:
            ret, frame = cam.read()
            out.write(frame)

            if not self.flag:
                break
        cam.release()
        out.release()
        cv.destroyAllWindows()

    async def do_test(self):
        self.flag = True
        _loop = asyncio.get_event_loop()
        result = await _loop.run_in_executor(None, self.recording)
        await asyncio.sleep(5)
        self.flag = False


async def read_and_send_vid(barcode, auth_token):
    name = f"{barcode}-{str(datetime.today().timestamp()).split('.')[0]}"
    url = f"url/{name}.avi"
    head = {
        "X-Auth-Token": auth_token,
        "Content-Type": "video/x-msvideo",
    }
    async with open('output.avi', mode='rb') as file:
        response = requests.post(url=url, head=head, files=file)
        if response.status_code == 201:
            return name


        
# mainfile: main.py
def main():
    QApplication.setAttribute(Qt.AA_UseDesktopOpenGL)
    app = QApplication(sys.argv)
    w = MainWindow()
    w.resize(1600, 900)
    w.show()

    try:
        loop = qasync.QEventLoop(app)
        asyncio.set_event_loop(loop)

    except asyncio.InvalidStateError as e:
        print(e + " Error in Qasync")

    with loop:

        loop.run_forever()


if __name__ == "__main__":
    main()

I would appreciate some help.
Thanks!!