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)
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 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
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())
self.device_info = 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_and_receive(messages.client_updates_config())
await self.send_and_receive(messages.get_keyboard_session())
self._heartbeat_task = asyncio.ensure_future(heartbeat_loop(self))