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)