async def _main(args): # parse the spi flash if args.spi_flash: with open(args.spi_flash, 'rb') as spi_flash_file: spi_flash = FlashMemory(spi_flash_file.read()) else: # Create memory containing default controller stick calibration spi_flash = FlashMemory() # Get controller name to emulate from arguments controller = Controller.from_arg(args.controller) with utils.get_output(path=args.log, default=None) as capture_file: # prepare the the emulated controller factory = controller_protocol_factory(controller, spi_flash=spi_flash) ctl_psm, itr_psm = 17, 19 transport, protocol = await create_hid_server(factory, reconnect_bt_addr=args.reconnect_bt_addr, ctl_psm=ctl_psm, itr_psm=itr_psm, capture_file=capture_file, device_id=args.device_id) controller_state = protocol.get_controller_state() # Create keyboard and mouse interface kmi = KMI(controller_state) # run the kmi try: await kmi.run() finally: logger.info('Stopping communication...') await transport.close()
async def _main(controller, reconnect_bt_addr=None, capture_file=None, spi_flash=None, device_id=None): factory = controller_protocol_factory(controller, spi_flash=spi_flash) ctl_psm, itr_psm = 17, 19 transport, protocol = await create_hid_server( factory, reconnect_bt_addr=reconnect_bt_addr, ctl_psm=ctl_psm, itr_psm=itr_psm, capture_file=capture_file, device_id=device_id) controller_state = protocol.get_controller_state() # Create command line interface and add some extra commands cli = ControllerCLI(controller_state) # Wrap the script so we can pass the controller state. The doc string will be printed when calling 'help' async def _run_test_controller_buttons(): """ test_buttons - Navigates to the "Test Controller Buttons" menu and presses all buttons. """ await test_controller_buttons(controller_state) # add the script from above cli.add_command('test_buttons', _run_test_controller_buttons) await cli.run() logger.info('Stopping communication...') await transport.close()
async def pre_init(app, controller, reconnect_bt_addr=None, capture_file=None, spi_flash=None, device_id=None): factory = controller_protocol_factory(controller, spi_flash=spi_flash) ctl_psm, itr_psm = 17, 19 transport, protocol = await create_hid_server(factory, reconnect_bt_addr=reconnect_bt_addr, ctl_psm=ctl_psm, itr_psm=itr_psm, capture_file=capture_file, device_id=device_id) controller_state = protocol.get_controller_state() controller_state = protocol.get_controller_state() controller_state.l_stick_state.set_center() controller_state.r_stick_state.set_center() await controller_state.connect() app.stick = controller_state.l_stick_state calibration = app.stick.get_calibration() app.maxUp = calibration.v_center + calibration.v_max_above_center app.maxDown = calibration.v_center - calibration.v_max_below_center app.maxRight = calibration.h_center + calibration.h_max_above_center app.maxLeft = calibration.h_center - calibration.h_max_below_center app.vCenter = calibration.v_center app.hCenter = calibration.h_center app.globalController = controller_state app.stick.set_h(app.hCenter) app.stick.set_v(app.vCenter)
async def get_controller(logger: Logger, switch_mac_address=None, spi_flash=None, controller='PRO_CONTROLLER', capture_file=None, device_id=None): log.configure(logger.level, logger.level) if spi_flash: with open(spi_flash, 'rb') as spi_flash_file: spi_flash = FlashMemory(spi_flash_file.read()) else: # Create memory containing default controller stick calibration spi_flash = FlashMemory() # Get controller name to emulate from arguments controller = Controller.from_arg(controller) factory = controller_protocol_factory(controller, spi_flash=spi_flash) ctl_psm, itr_psm = 17, 19 if switch_mac_address: logger.info("Pairing up with Switch MAC address: %s", switch_mac_address) transport, protocol = await create_hid_server( factory, reconnect_bt_addr=switch_mac_address, ctl_psm=ctl_psm, itr_psm=itr_psm, capture_file=capture_file, device_id=device_id) controller_state: ControllerState = protocol.get_controller_state() return SwitchController(logger, controller_state)
async def main(args): # parse the spi flash if args.spi_flash: with open(args.spi_flash, 'rb') as spi_flash_file: spi_flash = FlashMemory(spi_flash_file.read()) else: # Create memory containing default controller stick calibration spi_flash = FlashMemory() # Get controller name to emulate from arguments controller = Controller.from_arg(args.controller) with utils.get_output(path=args.log, default=None) as capture_file: # prepare the the emulated controller factory = controller_protocol_factory(controller, spi_flash=spi_flash) ctl_psm, itr_psm = 17, 19 transport, protocol = await create_hid_server(factory, reconnect_bt_addr=args.reconnect_bt_addr, ctl_psm=ctl_psm, itr_psm=itr_psm, capture_file=capture_file, device_id=args.device_id) controller_state = protocol.get_controller_state() await controller_state.connect() ## RUN CONTROLLER CODE HERE await xbox(controller_state) await transport.close()
async def _main(): controller = Controller.from_arg("PRO_CONTROLLER") factory = controller_protocol_factory(controller, spi_flash=FlashMemory()) print("waiting for 'Change Grip/Order' menu of the Switch.") transport, protocol = await create_hid_server(factory, ctl_psm=17, itr_psm=19) controller_state = protocol.get_controller_state() await controller_state.connect() print("controller connected.") await button_push(controller_state, "home", sec=0.1) await asyncio.sleep(1) await button_push(controller_state, "right", sec=0.1) await button_push(controller_state, "right", sec=0.1) await button_push(controller_state, "left", sec=0.1) await button_push(controller_state, "right", sec=0.1) await button_push(controller_state, "right", sec=0.1) await button_push(controller_state, "left", sec=0.1) await button_push(controller_state, "right", sec=0.1) await button_push(controller_state, "right", sec=0.1) await button_push(controller_state, "left", sec=0.1) controller_state.r_stick_state.set_right() await asyncio.sleep(60)
async def get_controller(reconnect_bt_addr=None, spi_flash=None, controller='PRO_CONTROLLER', capture_file=None, device_id=None): # parse the spi flash if spi_flash: with open(spi_flash, 'rb') as spi_flash_file: spi_flash = FlashMemory(spi_flash_file.read()) else: # Create memory containing default controller stick calibration spi_flash = FlashMemory() # Get controller name to emulate from arguments controller = Controller.from_arg(controller) factory = controller_protocol_factory(controller, spi_flash=spi_flash) ctl_psm, itr_psm = 17, 19 transport, protocol = await create_hid_server( factory, reconnect_bt_addr=reconnect_bt_addr, ctl_psm=ctl_psm, itr_psm=itr_psm, capture_file=capture_file, device_id=device_id) controller_state: ControllerState = protocol.get_controller_state() return SwitchController(controller_state)
async def _main(script, controller, reconnect_bt_addr=None, capture_file=None, spi_flash=None, device_id=None): factory = controller_protocol_factory(controller, spi_flash=spi_flash) ctl_psm, itr_psm = 17, 19 transport, protocol = await create_hid_server( factory, reconnect_bt_addr=reconnect_bt_addr, ctl_psm=ctl_psm, itr_psm=itr_psm, capture_file=capture_file, device_id=device_id) controller_state = protocol.get_controller_state() # Create command line interface and add some extra commands # cli = ControllerCLI(controller_state) print("I'll wait for 10 seconds before executing the sequence.") await asyncio.sleep(10) Exec = ScriptExecutor() Exec.CtrlState = controller_state if "options" in script: Exec.Options = ScriptOptions.fromDict(script["options"]) if "sequence" in script: await Exec.executeSequence(script["sequence"]) logger.info('Stopping communication...') await transport.close()
async def _main(bt_addr): # set up controller's flash memory data f = open('spi', 'rb') spi_flash = FlashMemory(f.read()) f.close() # connect via bluetooth factory = controller_protocol_factory(Controller.PRO_CONTROLLER, spi_flash=spi_flash) transport, protocol = await create_hid_server(factory, reconnect_bt_addr=bt_addr, ctl_psm=17, itr_psm=19) controller_state = protocol.get_controller_state() await controller_state.connect() print("Connected.") # start key listener thread keyboard_state = KeyboardState() listener = Listener(on_press=keyboard_state.key_down, on_release=keyboard_state.key_up, suppress=True) listener.start() # await button_push(controller_state, 'home', sec=5) pastTime = time.time() while listener.running: await main_loop(controller_state, keyboard_state)
async def _main(controller, capture_file=None, spi_flash=None): factory = controller_protocol_factory(controller, spi_flash=spi_flash) transport, protocol = await create_hid_server(factory, 17, 19, capture_file=capture_file) controller_state = protocol.get_controller_state() await controller_state.connect() con = NetController(controller_state) await con.run() logger.info('Stopping communication...') await transport.close()
async def loader(): if not os.geteuid() == 0: raise PermissionError('Script must be run as root!') transport, protocol = await create_hid_server(controller_protocol_factory( Controller.from_arg("PRO_CONTROLLER"), spi_flash=FlashMemory()), ctl_psm=17, itr_psm=19) controller_state = protocol.get_controller_state() return transport, controller_state
async def get_shared_controller(server_address, capture_file=None): """Communicates with sharing server to setup a shared controller session. Given a sharing server address, returns a connected protocol object and a server socket. The protocol object is a connected session that contains a ready-to-use controller state (running under 0x30 input mode). The server_conn is a socket object, which if written or make closed, will close the connection to sharing server immediately. Note that this function do only minimal error handling. The caller is responsible for catching any exception and closing the server connection. Args: - server_address: a Unix socket path. - capture_file: opened file for capturing transport output (for this shared session). Returns: A pair of (protocol, server_conn). """ loop = asyncio.get_event_loop() sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) await loop.sock_connect(sock, server_address) data_len, = struct.unpack('i', await loop.sock_recv(sock, 4)) msg, fds = recv_fds(sock, 2, 1) assert msg == b"fd" msg = b'' while len(msg) < data_len: msg += await loop.sock_recv(sock, data_len - len(msg)) msg = pickle.loads(msg) if msg.get("status") != "ok": raise ValueError("Failed to connect to controller server: {}".format( msg.get("msg", "unknown error"))) client_itr = socket.fromfd(fds[0], socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_L2CAP) controller, spi_flash = msg['controller'], msg['spi_flash'] protocol = controller_protocol_factory(controller, spi_flash=spi_flash)() transport = L2CAP_Transport(asyncio.get_event_loop(), protocol, client_itr, 50, capture_file=capture_file) protocol.connection_made(transport) # Start directly in input report 0x30 mode asyncio.ensure_future(protocol.input_report_mode_0x30()) return protocol, sock
async def _main(controller, capture_file=None, spi_flash=None, device_id=None): factory = controller_protocol_factory(controller, spi_flash=spi_flash) transport, protocol = await create_hid_server(factory, 17, 19, capture_file=capture_file, device_id=device_id) await test_controller_buttons(protocol.get_controller_state()) logger.info('Stopping communication...') await transport.close()
async def setup(reconnect_bt_addr): global controller_state factory = controller_protocol_factory(Controller.PRO_CONTROLLER, spi_flash=FlashMemory()) transport, protocol = await create_hid_server( factory, reconnect_bt_addr=reconnect_bt_addr, ctl_psm=17, itr_psm=19, capture_file=None, device_id=DEVICE) controller_state = protocol.get_controller_state() await controller_state.connect()
async def loader(recon): if not os.geteuid() == 0: raise PermissionError('Script must be run as root!') transport, protocol, recon_addr = await create_hid_server( controller_protocol_factory(Controller.from_arg("PRO_CONTROLLER"), spi_flash=FlashMemory()), reconnect_bt_addr=recon, ctl_psm=17, itr_psm=19) controller_state = protocol.get_controller_state() with open("./.reconnect", "w+") as f: f.write(recon_addr) return transport, controller_state
async def _main(controller, capture_file=None, spi_flash=None, device_id=None): factory = controller_protocol_factory(controller, spi_flash=spi_flash) transport, protocol = await create_hid_server(factory, 17, 19, capture_file=capture_file, device_id=device_id) try: await test_controller_buttons(protocol.get_controller_state()) except KeyboardInterrupt: pass except NotConnectedError: logger.error('Connection was lost.') finally: logger.info('Stopping communication...') await transport.close()
async def _main(args): # parse the spi flash if args.spi_flash: with open(args.spi_flash, 'rb') as spi_flash_file: spi_flash = FlashMemory(spi_flash_file.read()) else: # Create memory containing default controller stick calibration spi_flash = FlashMemory() # Get controller name to emulate from arguments controller = Controller.from_arg(args.controller) with utils.get_output(path=args.log, default=None) as capture_file: # prepare the the emulated controller factory = controller_protocol_factory(controller, spi_flash=spi_flash) ctl_psm, itr_psm = 17, 19 transport, protocol = await create_hid_server( factory, reconnect_bt_addr=args.reconnect_bt_addr, ctl_psm=ctl_psm, itr_psm=itr_psm, capture_file=capture_file, device_id=args.device_id) controller_state = protocol.get_controller_state() joycon_server = JoyConRestfull() th = threading.Thread(target=joycon_server.run) th.start() # Create command line interface and add some extra commands cli = ControllerCLI(controller_state, queue) _register_commands_with_controller_state(controller_state, cli) cli.add_command( 'amiibo', ControllerCLI.deprecated( 'Command was removed - use "nfc" instead!')) # set default nfc content supplied by argument if args.nfc is not None: await cli.commands['nfc'](args.nfc) #asyncio.ensure_future(cli.run()) #asyncio.ensure_future(app.run(port='5002')) # run the cli try: await cli.run() finally: logger.info('Stopping communication...') await transport.close()
async def create(self, configuration={}): """Initialize connection to the switch""" log.configure(logging.INFO) print("Connecting...") self.spi_flash = FlashMemory() self.controller = Controller.PRO_CONTROLLER self.factory = controller_protocol_factory( self.controller, spi_flash=self.spi_flash ) self.transport, self.protocol = await create_hid_server( self.factory, reconnect_bt_addr=configuration.get("reconnect_bt_addr") ) self.controller_state = self.protocol.get_controller_state() print("Connected!")
async def init(self,mac): self.spi_flash = FlashMemory() self.controller = Controller.PRO_CONTROLLER factory = controller_protocol_factory(self.controller, spi_flash=self.spi_flash) ctl_psm, itr_psm = 17, 19 self.transport, self.protocol, self.macAddress = await create_hid_server(factory, reconnect_bt_addr=mac, ctl_psm=ctl_psm, itr_psm=itr_psm, ) self.controller_state = self.protocol.get_controller_state() print("found switch initializing controller data") await self.controller_state.connect() print(self.macAddress) self.connected = True print("ready to use!")
async def _main(date_list_): controller_ = Controller.PRO_CONTROLLER factory = controller_protocol_factory(controller_) transport, protocol = await create_hid_server(factory, 17, 19) dr = protocol.get_controller_state() while 1: if await dr.connect(): print("蓝牙连接成功......") break mAutoJoy = auto_joy.AutoJoy(dr, date_list_[0], date_list_[1], date_list_[2]) await mAutoJoy.run() logger.info('Stopping communication...') await transport.close()
async def _main(args): # parse the spi flash if args.spi_flash: with open(args.spi_flash, 'rb') as spi_flash_file: spi_flash = FlashMemory(spi_flash_file.read()) else: # Create memory containing default controller stick calibration spi_flash = FlashMemory() # Get controller name to emulate from arguments controller = Controller.from_arg(args.controller) with utils.get_output(path=args.log, default=None) as capture_file: factory = controller_protocol_factory(controller, spi_flash=spi_flash) ctl_psm, itr_psm = 17, 19 transport, protocol = await create_hid_server( factory, reconnect_bt_addr=args.reconnect_bt_addr, ctl_psm=ctl_psm, itr_psm=itr_psm, capture_file=capture_file, device_id=args.device_id) controller_state = protocol.get_controller_state() # Create command line interface and add some extra commands cli = ControllerCLI(controller_state) # Wrap the script so we can pass the controller state. The doc string will be printed when calling 'help' async def _run_Controller(): ''' - Controller ''' await xbox(controller_state) # add the script from above #cli.add_command('mash', call_mash_button) cli.add_command('Controller', _run_Controller) cli.add_command('controller', _run_Controller) try: await cli.run() finally: logger.info('Stopping communication...') await transport.close()
async def get_controller(logger: Logger, switch_mac_address=None, spi_flash=None, controller='PRO_CONTROLLER', capture_file=None, device_id=None): logger.info("Simulating a %s controller.", controller) if spi_flash: with open(spi_flash, 'rb') as spi_flash_file: spi_flash = FlashMemory(spi_flash_file.read()) else: # Create memory containing default controller stick calibration spi_flash = FlashMemory() # Get controller name to emulate from arguments controller = Controller.from_arg(controller) factory = controller_protocol_factory(controller, spi_flash=spi_flash) ctl_psm, itr_psm = 17, 19 if switch_mac_address: logger.info("Pairing with Switch MAC address: %s", switch_mac_address) while True: try: transport, protocol = await create_hid_server( factory, reconnect_bt_addr=switch_mac_address, ctl_psm=ctl_psm, itr_psm=itr_psm, capture_file=capture_file, device_id=device_id) controller_state: ControllerState = protocol.get_controller_state( ) break except: # TODO Try to wake the Switch up from sleep. wait_s = 3 logger.exception( "Error pairing. Make sure your Switch is on." " Will try again in %ds.", wait_s) await asyncio.sleep(wait_s) logger.info("Simulated %s paired.", controller.name) return SwitchController(logger, controller_state)
async def _main(args): # parse the spi flash if args.spi_flash: with open(args.spi_flash, 'rb') as spi_flash_file: spi_flash = FlashMemory(spi_flash_file.read()) else: # Create memory containing default controller stick calibration spi_flash = FlashMemory() # Get controller name to emulate from arguments controller = Controller.from_arg(args.controller) with utils.get_output(path=args.log, default=None) as capture_file: # prepare the the emulated controller factory = controller_protocol_factory(controller, spi_flash=spi_flash) ctl_psm, itr_psm = 17, 19 if args.bt_addr_file is not None: bt_addr = open(args.bt_addr_file, "r").read() if bt_addr == "ANY": bt_addr = None else: bt_addr = args.reconnect_bt_addr transport, protocol = await create_hid_server( factory, reconnect_bt_addr=bt_addr, ctl_psm=ctl_psm, itr_psm=itr_psm, capture_file=capture_file, device_id=args.device_id) controller_state = protocol.get_controller_state() # Create socket interface and add some extra commands socket_interface = ControllerSocketInterface(args.socket, controller_state) _register_commands_with_controller_state(controller_state, socket_interface) # run the socket_interface await socket_interface.start_server() return socket_interface, transport
async def main(args, q): # parse the spi flash logger.name = "CLI进程" if args.spi_flash: with open(args.spi_flash, 'rb') as spi_flash_file: spi_flash = FlashMemory(spi_flash_file.read()) else: # Create memory containing default controller stick calibration spi_flash = FlashMemory() # Get controller name to emulate from arguments controller = Controller.from_arg(args.controller) with utils.get_output(path=args.log, default=None) as capture_file: # prepare the the emulated controller factory = controller_protocol_factory(controller, spi_flash=spi_flash) ctl_psm, itr_psm = 17, 19 transport, protocol = await create_hid_server( factory, reconnect_bt_addr=args.reconnect_bt_addr, ctl_psm=ctl_psm, itr_psm=itr_psm, capture_file=capture_file, device_id=args.device_id) controller_state = protocol.get_controller_state() joycontrol_http.controller_state = controller_state method = controller_state.button_state.set_button q.put(method) logger.debug("controller开始监听") while True: await asyncio.sleep(0.1) if q.empty(): continue msg = q.get() if isinstance(msg, Command): if msg.target == "controller": if msg.cmd == "btn_push": from joycontrol.controller_state import button_push await button_push(controller_state, msg.obj)
async def _main(controller, reconnect_bt_addr=None, capture_file=None, spi_flash=None, device_id=None): factory = controller_protocol_factory(controller, spi_flash=spi_flash) ctl_psm, itr_psm = 17, 19 transport, protocol = await create_hid_server( factory, reconnect_bt_addr=reconnect_bt_addr, ctl_psm=ctl_psm, itr_psm=itr_psm, capture_file=capture_file, device_id=device_id) controller_state = protocol.get_controller_state() cli = ControllerCLI(controller_state) await cli.run() logger.info('Stopping communication...') await transport.close()
async def run_joycontrol(self): factory = controller_protocol_factory(Controller.PRO_CONTROLLER) ctl_psm, itr_psm = 17, 19 transport, protocol = await create_hid_server(factory, ctl_psm=ctl_psm, itr_psm=itr_psm) controller_state = protocol.get_controller_state() #controller_state.l_stick_state.set_center() #controller_state.r_stick_state.set_center() await controller_state.connect() print("connected") self.proctrl.connected = True self.draw() while True: func = await self.joycontrol_q.async_q.get() if func != None: func(controller_state) await controller_state.send() else: break
async def start(self, args): # Create memory containing default controller stick calibration spi_flash = FlashMemory() # Get controller name to emulate from arguments controller = Controller.from_arg('PRO_CONTROLLER') with utils.get_output(path=None, default=None) as capture_file: factory = controller_protocol_factory(controller, spi_flash=spi_flash) ctl_psm, itr_psm = 17, 19 transport, protocol = await create_hid_server( factory, reconnect_bt_addr=args.reconnect_bt_addr, ctl_psm=ctl_psm, itr_psm=itr_psm, capture_file=capture_file, device_id=args.device_id) controller_state = protocol.get_controller_state() self.transport = transport try: # waits until controller is fully connected await controller_state.connect() joycontrol_plugin = self.__load_plugin(args.plugin, controller_state, args.plugin_options) await joycontrol_plugin.run() except Exception as e: logger.error(e) finally: logger.info('Stopping communication...') await transport.close() self.transport = None self.joycontrol_cmd = None
async def _main(controller, capture_file=None, spi_flash=None, device_id=None, share_controller_address=None): factory = controller_protocol_factory(controller, spi_flash=spi_flash) global transport, protocol transport, protocol = await create_hid_server(factory, 17, 19, capture_file=capture_file, device_id=device_id) controller_state = protocol.get_controller_state() if share_controller_address is not None: asyncio.ensure_future( start_share_controller_server(protocol, share_controller_address)) cli = ControllerCLI(controller_state) await cli.run() logger.info('Stopping communication...') await transport.close()
async def _main(args): # Create memory containing default controller stick calibration spi_flash = FlashMemory() # Get controller name to emulate from arguments controller = Controller.PRO_CONTROLLER with utils.get_output(path=args.log, default=None) as capture_file: factory = controller_protocol_factory(controller, spi_flash=spi_flash) transport, protocol = await create_hid_server( factory, ctl_psm=17, itr_psm=19, capture_file=capture_file) controller_state = protocol.get_controller_state() # Create command line interface and add some extra commands cli = command.CCLI(controller_state) try: await controller_state.connect() await cli.run() finally: logger.info('Stopping communication...') await transport.close()
async def _main(args): # parse the spi flash if args.spi_flash: with open(args.spi_flash, 'rb') as spi_flash_file: spi_flash = FlashMemory(spi_flash_file.read()) else: # Create memory containing default controller stick calibration spi_flash = FlashMemory() # Get controller name to emulate from arguments controller = Controller.from_arg(args.controller) with utils.get_output(path=args.log, default=None) as capture_file: factory = controller_protocol_factory(controller, spi_flash=spi_flash) ctl_psm, itr_psm = 17, 19 transport, protocol = await create_hid_server( factory, reconnect_bt_addr=args.reconnect_bt_addr, ctl_psm=ctl_psm, itr_psm=itr_psm, capture_file=capture_file, device_id=args.device_id) controller_state = protocol.get_controller_state() # Create command line interface and add some extra commands cli = ControllerCLI(controller_state) # Wrap the script so we can pass the controller state. The doc string will be printed when calling 'help' async def _run_test_controller_buttons(): """ test_buttons - Navigates to the "Test Controller Buttons" menu and presses all buttons. """ await test_controller_buttons(controller_state) # add the script from above cli.add_command('test_buttons', _run_test_controller_buttons) # Create amiibo command async def amiibo(*args): """ amiibo - Sets amiibo content Usage: amiibo <file_name> Set controller state NFC content to file amiibo remove Remove NFC content from controller state """ if controller_state.get_controller() == Controller.JOYCON_L: raise ValueError('NFC content cannot be set for JOYCON_L') elif not args: raise ValueError( '"amiibo" command requires amiibo dump file path as argument!' ) elif args[0] == 'remove': controller_state.set_nfc(None) print('Removed nfc content.') else: await set_amiibo(controller_state, args[0]) # add the script from above cli.add_command('amiibo', amiibo) try: await cli.run() finally: logger.info('Stopping communication...') await transport.close()