def pair_with_device(loop):
"""Make it possible to pair with device."""
my_zeroconf = Zeroconf()
details = conf.AppleTV('127.0.0.1', 'Apple TV')
details.add_service(conf.DmapService('login_id'))
atv = pyatv.connect_to_apple_tv(details, loop)
yield from atv.pairing.start(zeroconf=my_zeroconf,
name=REMOTE_NAME,
pin=PIN_CODE)
print('You can now pair with pyatv')
# Wait for a minute to allow pairing
yield from asyncio.sleep(60, loop=loop)
yield from atv.pairing.stop()
# Give some feedback about the process
if atv.pairing.has_paired:
pairing_guid = yield from atv.pairing.get('pairing_gui')
print('Paired with device!')
print('Pairing guid: ' + pairing_guid)
else:
print('Did not pair with device!')
my_zeroconf.close()
async def mock_pairing(event_loop):
obj = MagicMock()
service = conf.DmapService(None, None)
config = conf.AppleTV("Apple TV", "127.0.0.1")
config.add_service(service)
zeroconf = zeroconf_stub.stub(pairing)
async def _start(pin_code=PIN_CODE,
pairing_guid=PAIRING_GUID,
name=REMOTE_NAME):
options = {"zeroconf": zeroconf}
if pairing_guid:
options["pairing_guid"] = pairing_guid
if name:
options["name"] = name
obj.pairing = pairing.DmapPairingHandler(config, await
http.create_session(),
event_loop, **options)
await obj.pairing.begin()
obj.pairing.pin(pin_code)
return obj.pairing, zeroconf, service
yield _start
await obj.pairing.finish()
await obj.pairing.close()
def _handle_service(
self,
address,
name: str,
service: interface.BaseService,
response: mdns.Response,
) -> None:
_LOGGER.debug(
"Auto-discovered %s at %s:%d (%s)",
name,
address,
service.port,
service.protocol,
)
if address not in self._found_devices:
# Extract properties from extra services that might be of interest
extra_properties: Dict[str, str] = {}
for extra_service in EXTRA_SERVICES:
extra_properties.update(
_get_service_properties(response.services, extra_service))
self._found_devices[address] = conf.AppleTV(
address,
name,
deep_sleep=response.deep_sleep,
model=lookup_internal_name(response.model),
properties=extra_properties,
)
self._found_devices[address].add_service(service)
async def discover(self, timeout: int) -> Mapping[IPv4Address, BaseConfig]:
"""Start discovery of devices and services."""
await self.process(timeout)
devices = {}
for address, found_device in self._found_devices.items():
device_info = self._get_device_info(found_device)
devices[address] = conf.AppleTV(
address,
found_device.name,
deep_sleep=found_device.deep_sleep,
properties=self._properties[address],
device_info=device_info,
)
for service in found_device.services:
devices[address].add_service(service)
properties_map = {
service.protocol: service
for service in devices[address].services
}
for device_service in devices[address].services:
# Apply service_info after adding all services in case a merge happens.
# We know services are of type MutableService here.
await self._service_infos[device_service.protocol
](cast(MutableService,
device_service), device_info,
properties_map)
return devices
async def test_auto_connect_with_device(mock_scan, mock_connect):
obj = MagicMock()
obj.found = None
obj.closed = False
def _close():
obj.closed = True
config = conf.AppleTV("address", "name")
mock_device = MagicMock()
mock_scan.append(config)
async def _connect(*arsgs):
return mock_device
mock_connect.side_effect = _connect
async def found_handler(atv):
obj.found = atv
await helpers.auto_connect(found_handler)
assert obj.found == mock_device
mock_device.close.assert_called_once()
def test_equality(self):
self.assertEqual(self.atv, self.atv)
atv2 = conf.AppleTV(ADDRESS_2, NAME)
self.assertNotEqual(self.atv, atv2)
atv2.address = ADDRESS_1
self.assertEqual(self.atv, atv2)
def test_empty_device_info(config):
config = conf.AppleTV(ADDRESS_1, NAME)
device_info = config.device_info
assert device_info.operating_system == OperatingSystem.Unknown
assert device_info.version is None
assert device_info.build_number is None
assert device_info.model == DeviceModel.Unknown
assert device_info.mac is None
def _handle_service(self, address, name, service):
if address not in self._found_devices:
self._found_devices[address] = conf.AppleTV(address, name)
_LOGGER.debug('Auto-discovered %s at %s:%d (%s)', name, address,
service.port, service.protocol)
atv = self._found_devices[address]
atv.add_service(service)
def setUp(self):
self.config = conf.AppleTV(ADDRESS_1, NAME)
self.dmap_service = conf.DmapService(IDENTIFIER_1, None, port=PORT_1)
self.mrp_service = conf.MrpService(
IDENTIFIER_2, PORT_2, properties=MRP_PROPERTIES
)
self.airplay_service = conf.AirPlayService(
IDENTIFIER_3, PORT_1, properties=AIRPLAY_PROPERTIES
)
async def setUp(self):
self.service = conf.DmapService(None, None)
self.config = conf.AppleTV('Apple TV', '127.0.0.1')
self.config.add_service(self.service)
self.zeroconf = zeroconf_stub.stub(pairing)
self.pairing = None
# TODO: currently stubs internal method, should provide stub
# for netifaces later
pairing._get_private_ip_addresses = \
lambda: [ipaddress.ip_address('10.0.0.1')]
async def print_what_is_playing(loop):
"""Connect to device and print what is playing."""
config = conf.AppleTV(ADDRESS, NAME)
config.add_service(conf.DmapService("some_id", HSGID))
print("Connecting to {0}".format(config.address))
atv = await connect(config, loop)
try:
print(await atv.metadata.playing())
finally:
# Do not forget to close
await atv.close()
def print_what_is_playing(loop):
"""Connect to device and print what is playing."""
details = conf.AppleTV(ADDRESS, NAME)
details.add_service(conf.DmapService(HSGID))
print('Connecting to {}'.format(details.address))
atv = pyatv.connect_to_apple_tv(details, loop)
try:
print((yield from atv.metadata.playing()))
finally:
# Do not forget to logout
yield from atv.logout()
async def print_what_is_playing(loop):
"""Connect to device and print what is playing."""
config = conf.AppleTV(ADDRESS, NAME)
config.add_service(
conf.ManualService("some_id", Protocol.DMAP, 3689, {}, credentials=HSGID)
)
print(f"Connecting to {config.address}")
atv = await connect(config, loop)
try:
print(await atv.metadata.playing())
finally:
# Do not forget to close
atv.close()
def setUp(self):
self.atv = conf.AppleTV(ADDRESS_1,
NAME,
supported_services=SUPPORTED_PROTOCOLS)
self.service_mock = MagicMock()
self.service_mock.protocol = PROTOCOL_1
self.service_mock.port = PORT_1
self.service_mock.is_usable.return_value = False
self.service_mock.superseeded_by.return_value = False
self.service_mock2 = MagicMock()
self.service_mock2.protocol = PROTOCOL_2
self.service_mock2.port = PORT_2
self.service_mock2.is_usable.return_value = False
self.service_mock2.superseeded_by.return_value = False
def setUp(self):
self.config = conf.AppleTV(ADDRESS_1, NAME)
self.service_mock = MagicMock()
self.service_mock.protocol = const.Protocol.DMAP
self.service_mock.port = PORT_1
self.service_mock.identifier = IDENTIFIER_1
self.service_mock.credentials = None
self.service_mock2 = MagicMock()
self.service_mock2.protocol = const.Protocol.MRP
self.service_mock2.port = PORT_2
self.service_mock2.identifier = IDENTIFIER_2
self.airplay_mock = MagicMock()
self.airplay_mock.port = PORT_1
self.airplay_mock.protocol = Protocol.AirPlay
def test_airport_express_extra_properties():
extra_properties = {
# MAC, raMA=2.4GHz MAC, raM2=5GHz MAC
"wama":
"AA-AA-AA-AA-AA-AA,raMA=BB-BB-BB-BB-BB-BB,raM2=CC-CC-CC-CC-CC-CC," +
"raNm=MySsid,raCh=11,rCh2=112,raSt=1,raNA=0,syFl=0x80C,syAP=115,syVs=7.8.1,"
+ "srcv=78100.3,bjSd=2"
}
config = conf.AppleTV(ADDRESS_1,
NAME,
deep_sleep=True,
properties=extra_properties)
config.add_service(AIRPORT_SERVICE)
device_info = config.device_info
assert device_info.operating_system == OperatingSystem.AirPortOS
assert device_info.version == "7.8.1"
assert device_info.build_number is None
assert device_info.model == DeviceModel.AirPortExpressGen2
assert device_info.mac == "AA:AA:AA:AA:AA:AA"
def _handle_service(self, address, name, service):
if address not in self.found_devices:
self.found_devices[address] = conf.AppleTV(address, name)
_LOGGER.debug('Auto-discovered %s at %s:%d (protocol: %s)', name,
address, service.port, service.protocol)
atv = self.found_devices[address]
atv.add_service(service)
# Check if we should continue to run or not
if self._should_abort(address):
_LOGGER.debug('Aborting since a device was found')
# Only return the found device as a convenience to the user
self.found_devices = {address: atv}
# zeroconf is run in a different thread so this must be a
# thread-safe call
self.loop.call_soon_threadsafe(self.semaphore.release)
def _handle_service(
self,
address,
name: str,
service: interface.BaseService,
response: mdns.Response,
) -> None:
_LOGGER.debug(
"Auto-discovered %s at %s:%d (%s)",
name,
address,
service.port,
service.protocol,
)
self._found_devices.setdefault(
address,
conf.AppleTV(
address,
name,
deep_sleep=response.deep_sleep,
model=lookup_internal_name(response.model),
),
).add_service(service)
def setUp(self):
self.device_details = conf.AppleTV('address', 'name')
self.mock_device = asynctest.mock.Mock(MockAppleTV())
def test_equality(config):
assert config == config
atv2 = conf.AppleTV(ADDRESS_1, NAME)
atv2.add_service(conf.AirPlayService(IDENTIFIER_1, PORT_1))
assert config != atv2
def config():
yield conf.AppleTV(ADDRESS_1,
NAME,
deep_sleep=True,
model=DeviceModel.Gen2)
def test_equality(self):
self.assertEqual(self.config, self.config)
atv2 = conf.AppleTV(ADDRESS_1, NAME)
atv2.add_service(conf.AirPlayService(IDENTIFIER_1, PORT_1))
self.assertNotEqual(self.config, atv2)
def create_conf(name, address, *services):
"""Create an Apple TV configuration."""
atv = conf.AppleTV(name, address)
for service in services:
atv.add_service(service)
return atv
def setUp(self):
self.config = conf.AppleTV(ADDRESS_1, NAME)
self.dmap_service = conf.DmapService(IDENTIFIER_1, None, port=PORT_1)
self.mrp_service = conf.MrpService(IDENTIFIER_2, PORT_2)
self.airplay_service = conf.AirPlayService(IDENTIFIER_3, PORT_1)
