async def mrp_protocol(event_loop, mrp_atv):
port = mrp_atv.get_port(Protocol.MRP)
service = MrpService("mrp_id", port)
connection = MrpConnection("127.0.0.1", port, event_loop)
protocol = MrpProtocol(connection, SRPAuthHandler(), service)
yield protocol
protocol.stop()
class MrpAppleTV(AppleTV):
"""Implementation of API support for Apple TV."""
# This is a container class so it's OK with many attributes
# pylint: disable=too-many-instance-attributes
def __init__(
self,
loop: asyncio.AbstractEventLoop,
session_manager: ClientSessionManager,
config: conf.AppleTV,
airplay: Stream,
) -> None:
"""Initialize a new Apple TV."""
super().__init__()
self._session_manager = session_manager
self._config = config
self._mrp_service = config.get_service(Protocol.MRP)
assert self._mrp_service is not None
self._connection = MrpConnection(config.address,
self._mrp_service.port,
loop,
atv=self)
self._srp = SRPAuthHandler()
self._protocol = MrpProtocol(self._connection, self._srp,
self._mrp_service)
self._psm = PlayerStateManager(self._protocol, loop)
self._mrp_remote = MrpRemoteControl(loop, self._psm, self._protocol)
self._mrp_metadata = MrpMetadata(self._protocol, self._psm,
config.identifier)
self._mrp_power = MrpPower(loop, self._protocol, self._mrp_remote)
self._mrp_push_updater = MrpPushUpdater(loop, self._mrp_metadata,
self._psm)
self._mrp_features = MrpFeatures(self._config, self._psm)
self._airplay = airplay
async def connect(self) -> None:
"""Initiate connection to device.
No need to call it yourself, it's done automatically.
"""
await self._protocol.start()
def close(self) -> None:
"""Close connection and release allocated resources."""
asyncio.ensure_future(self._session_manager.close())
self._airplay.close()
self.push_updater.stop()
self._protocol.stop()
@property
def device_info(self) -> DeviceInfo:
"""Return API for device information."""
return self._config.device_info
@property
def service(self):
"""Return service used to connect to the Apple TV."""
return self._mrp_service
@property
def remote_control(self) -> RemoteControl:
"""Return API for controlling the Apple TV."""
return self._mrp_remote
@property
def metadata(self) -> Metadata:
"""Return API for retrieving metadata from Apple TV."""
return self._mrp_metadata
@property
def push_updater(self) -> PushUpdater:
"""Return API for handling push update from the Apple TV."""
return self._mrp_push_updater
@property
def stream(self) -> Stream:
"""Return API for streaming media."""
return self._airplay
@property
def power(self) -> Power:
"""Return API for streaming media."""
return self._mrp_power
@property
def features(self) -> Features:
"""Return features interface."""
return self._mrp_features
class MrpAppleTV(AppleTV):
"""Implementation of API support for Apple TV."""
# This is a container class so it's OK with many attributes
# pylint: disable=too-many-instance-attributes
def __init__(self, loop, session, config, airplay):
"""Initialize a new Apple TV."""
super().__init__()
self._session = session
self._mrp_service = config.get_service(Protocol.MRP)
self._connection = MrpConnection(config.address,
self._mrp_service.port,
loop,
atv=self)
self._srp = SRPAuthHandler()
self._protocol = MrpProtocol(loop, self._connection, self._srp,
self._mrp_service)
self._psm = PlayerStateManager(self._protocol, loop)
self._mrp_remote = MrpRemoteControl(loop, self._protocol)
self._mrp_metadata = MrpMetadata(self._protocol, self._psm,
config.identifier)
self._mrp_push_updater = MrpPushUpdater(loop, self._mrp_metadata,
self._psm)
self._airplay = airplay
async def connect(self):
"""Initiate connection to device.
No need to call it yourself, it's done automatically.
"""
await self._protocol.start()
async def close(self):
"""Close connection and release allocated resources."""
if net.is_custom_session(self._session):
await self._session.close()
self._protocol.stop()
@property
def service(self):
"""Return service used to connect to the Apple TV."""
return self._mrp_service
@property
def remote_control(self):
"""Return API for controlling the Apple TV."""
return self._mrp_remote
@property
def metadata(self):
"""Return API for retrieving metadata from Apple TV."""
return self._mrp_metadata
@property
def push_updater(self):
"""Return API for handling push update from the Apple TV."""
return self._mrp_push_updater
@property
def stream(self):
"""Return API for streaming media."""
return self._airplay
class MrpAppleTV(AppleTV):
"""Implementation of API support for Apple TV."""
# This is a container class so it's OK with many attributes
# pylint: disable=too-many-instance-attributes
def __init__(self, loop, session, details, airplay):
"""Initialize a new Apple TV."""
super().__init__()
self._session = session
self._mrp_service = details.usable_service()
self._connection = MrpConnection(details.address,
self._mrp_service.port, loop)
self._srp = SRPAuthHandler()
self._protocol = MrpProtocol(loop, self._connection, self._srp,
self._mrp_service)
self._mrp_remote = MrpRemoteControl(loop, self._protocol)
self._mrp_metadata = MrpMetadata(self._protocol)
self._mrp_push_updater = MrpPushUpdater(loop, self._mrp_metadata,
self._protocol)
self._mrp_pairing = MrpPairingHandler(self._protocol, self._srp,
self._mrp_service)
self._airplay = airplay
async def login(self):
"""Perform an explicit login."""
await self._protocol.start()
async def logout(self):
"""Perform an explicit logout.
Must be done when session is no longer needed to not leak resources.
"""
await self._session.close()
self._protocol.stop()
@property
def service(self):
"""Return service used to connect to the Apple TV.."""
return self._mrp_service
@property
def pairing(self):
"""Return API for pairing with the Apple TV."""
return self._mrp_pairing
@property
def remote_control(self):
"""Return API for controlling the Apple TV."""
return self._mrp_remote
@property
def metadata(self):
"""Return API for retrieving metadata from Apple TV."""
return self._mrp_metadata
@property
def push_updater(self):
"""Return API for handling push update from the Apple TV."""
return self._mrp_push_updater
@property
def airplay(self):
"""Return API for working with AirPlay."""
return self._airplay