async def start(self, skip_initial_messages=False): """Connect to device and listen to incoming messages.""" if self.connection.connected: return await self.connection.connect() # In case credentials have been given externally (i.e. not by pairing # with a device), then use that client id if self.service.credentials: self.srp.pairing_id = Credentials.parse( self.service.credentials).client_id # The first message must always be DEVICE_INFORMATION, otherwise the # device will not respond with anything msg = messages.device_information('pyatv', self.srp.pairing_id.decode()) await self.send_and_receive(msg) self._initial_message_sent = True # This is a hack to support re-use of a protocol object in # proxy (will be removed/refactored later) if skip_initial_messages: return await self._connect_and_encrypt() # This should be the first message sent after encryption has # been enabled await self.send(messages.set_connection_state()) # Subscribe to updates at this stage await self.send(messages.client_updates_config()) await self.send_and_receive(messages.get_keyboard_session())
async def _enable_encryption(self): # Encryption can be enabled whenever credentials are available but only # after DEVICE_INFORMATION has been sent if self.service.credentials: # Verify credentials and generate keys credentials = Credentials.parse(self.service.credentials) pair_verifier = MrpPairingVerifier(self, self.srp, credentials) try: await pair_verifier.verify_credentials() output_key, input_key = pair_verifier.encryption_keys() self.connection.enable_encryption(output_key, input_key) except Exception as ex: raise exceptions.AuthenticationError(str(ex)) from ex
async def start(self, skip_initial_messages=False): """Connect to device and listen to incoming messages.""" if self._state != ProtocolState.NOT_CONNECTED: raise exceptions.InvalidStateError(self._state.name) self._state = ProtocolState.CONNECTING try: await self.connection.connect() self._state = ProtocolState.CONNECTED # In case credentials have been given externally (i.e. not by pairing # with a device), then use that client id if self.service.credentials: self.srp.pairing_id = Credentials.parse( self.service.credentials).client_id # The first message must always be DEVICE_INFORMATION, otherwise the # device will not respond with anything msg = messages.device_information("pyatv", self.srp.pairing_id.decode()) self.device_info = await self.send_and_receive(msg) # This is a hack to support re-use of a protocol object in # proxy (will be removed/refactored later) if skip_initial_messages: return await self._enable_encryption() # This should be the first message sent after encryption has # been enabled await self.send(messages.set_connection_state()) # Subscribe to updates at this stage await self.send_and_receive(messages.client_updates_config()) await self.send_and_receive(messages.get_keyboard_session()) self._heartbeat_task = asyncio.ensure_future(heartbeat_loop(self)) except Exception: # Something went wrong, let's do cleanup self.stop() raise else: # We're now ready self._state = ProtocolState.READY
async def _connect_and_encrypt(self): if not self.connection.connected: await self.start() # Encryption can be enabled whenever credentials are available but only # after DEVICE_INFORMATION has been sent if self.service.credentials and self._initial_message_sent: self._initial_message_sent = False # Verify credentials and generate keys credentials = Credentials.parse(self.service.credentials) pair_verifier = MrpPairingVerifier(self, self.srp, credentials) await pair_verifier.verify_credentials() output_key, input_key = pair_verifier.encryption_keys() self.connection.enable_encryption(output_key, input_key)
async def start(self): """Connect to device and listen to incoming messages.""" if self.connection.connected: return await self.connection.connect() # In case credentials have been given externally (i.e. not by pairing # with a device), then use that client id if self.service.device_credentials: self.srp.pairing_id = Credentials.parse( self.service.device_credentials).client_id # The first message must always be DEVICE_INFORMATION, otherwise the # device will not respond with anything msg = messages.device_information( 'pyatv', self.srp.pairing_id.decode()) await self.send_and_receive(msg) self._initial_message_sent = True # This should be the first message sent after encryption has # been enabled await self.send(messages.set_ready_state()) async def _wait_for_updates(_, semaphore): # Use a counter here whenever more than one message is expected semaphore.release() # Wait for some stuff to arrive before returning semaphore = asyncio.Semaphore(value=0, loop=self.loop) self.add_listener(_wait_for_updates, protobuf.SET_STATE_MESSAGE, data=semaphore, one_shot=True) # Subscribe to updates at this stage await self.send(messages.client_updates_config()) await self.send(messages.wake_device()) try: await asyncio.wait_for( semaphore.acquire(), 1, loop=self.loop) except asyncio.TimeoutError: # This is not an issue itself, but I should do something better. # Basically this gives the device about one second to respond with # some metadata before continuing. pass
async def finish(self): """Stop pairing process.""" if not self.pin_code: raise exceptions.PairingError("no pin given") credentials = str(await error_handler( self.pairing_procedure.finish_pairing, exceptions.PairingError, self.pin_code, )) _LOGGER.debug("Verifying credentials %s", credentials) verifier = MrpPairingVerifier(self.protocol, self.srp, Credentials.parse(credentials)) await error_handler(verifier.verify_credentials, exceptions.PairingError) self.service.credentials = credentials self._has_paired = True