def __init__(self, name, host, optimistic=False, timeout=DEFAULT_TIMEOUT):
"""Initialize the device."""
from pymediaroom import Remote
self.stb = Remote(host, timeout=timeout)
_LOGGER.info("Found %s at %s%s", name, host,
" - I'm optimistic" if optimistic else "")
self._name = name
self._is_standby = not optimistic
self._current = None
self._optimistic = optimistic
self._state = STATE_STANDBY
def __init__(self, host, device_id, optimistic=False, timeout=DEFAULT_TIMEOUT):
"""Initialize the device."""
self.host = host
self.stb = Remote(host)
_LOGGER.info(
"Found STB at %s%s", host, " - I'm optimistic" if optimistic else ""
)
self._channel = None
self._optimistic = optimistic
self._state = STATE_PLAYING if optimistic else STATE_STANDBY
self._name = "Mediaroom {}".format(device_id if device_id else host)
self._available = True
if device_id:
self._unique_id = device_id
else:
self._unique_id = None
def __init__(self, name, host, optimistic=False, timeout=DEFAULT_TIMEOUT):
"""Initialize the device."""
from pymediaroom import Remote
self.stb = Remote(host, timeout=timeout)
_LOGGER.info(
"Found %s at %s%s", name, host,
" - I'm optimistic" if optimistic else "")
self._name = name
self._is_standby = not optimistic
self._current = None
self._optimistic = optimistic
self._state = STATE_STANDBY
def __init__(
self, host, device_id, optimistic=False, timeout=DEFAULT_TIMEOUT):
"""Initialize the device."""
from pymediaroom import Remote
self.host = host
self.stb = Remote(host)
_LOGGER.info("Found STB at %s%s", host,
" - I'm optimistic" if optimistic else "")
self._channel = None
self._optimistic = optimistic
self._state = STATE_PLAYING if optimistic else STATE_STANDBY
self._name = 'Mediaroom {}'.format(device_id if device_id else host)
self._available = True
if device_id:
self._unique_id = device_id
else:
self._unique_id = None
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the Mediaroom platform."""
hosts = []
known_hosts = hass.data.get(DATA_MEDIAROOM)
if known_hosts is None:
known_hosts = hass.data[DATA_MEDIAROOM] = []
host = config.get(CONF_HOST, None)
if host is None:
_LOGGER.info("Trying to discover Mediaroom STB")
from pymediaroom import Remote
host = Remote.discover(known_hosts)
if host is None:
_LOGGER.warning("Can't find any STB")
return
hosts.append(host)
known_hosts.append(host)
stbs = []
try:
for host in hosts:
stbs.append(MediaroomDevice(
config.get(CONF_NAME),
host,
config.get(CONF_OPTIMISTIC),
config.get(CONF_TIMEOUT)
))
except ConnectionRefusedError:
hass.components.persistent_notification.create(
'Error: Unable to initialize mediaroom at {}<br />'
'Check its network connection or consider '
'using auto discovery.<br />'
'You will need to restart hass after fixing.'
''.format(host),
title=NOTIFICATION_TITLE,
notification_id=NOTIFICATION_ID)
add_devices(stbs)
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the Mediaroom platform."""
hosts = []
known_hosts = hass.data.get(DATA_MEDIAROOM)
if known_hosts is None:
known_hosts = hass.data[DATA_MEDIAROOM] = []
host = config.get(CONF_HOST, None)
if host is None:
_LOGGER.info("Trying to discover Mediaroom STB")
from pymediaroom import Remote
host = Remote.discover(known_hosts)
if host is None:
_LOGGER.warning("Can't find any STB")
return
hosts.append(host)
known_hosts.append(host)
stbs = []
try:
for host in hosts:
stbs.append(
MediaroomDevice(config.get(CONF_NAME), host,
config.get(CONF_OPTIMISTIC),
config.get(CONF_TIMEOUT)))
except ConnectionRefusedError:
hass.components.persistent_notification.create(
'Error: Unable to initialize mediaroom at {}<br />'
'Check its network connection or consider '
'using auto discovery.<br />'
'You will need to restart hass after fixing.'
''.format(host),
title=NOTIFICATION_TITLE,
notification_id=NOTIFICATION_ID)
add_devices(stbs)
async def main(loop):
stbs = await discover(max_wait=5, loop=loop)
stbs = sorted(list(stbs))
if stbs:
logging.info("Found {}".format(stbs))
remote = Remote(stbs[0])
#remote = Remote("192.168.1.69", loop=loop)
await install_mediaroom_protocol(
responses_callback=remote.notify_callback)
while remote.state == State.UNKNOWN:
await asyncio.sleep(5)
await remote.turn_on()
await remote.send_cmd('Rose')
await remote.send_cmd('Rose')
await asyncio.sleep(10)
else:
logging.error("No STB Found")
class MediaroomDevice(MediaPlayerDevice):
"""Representation of a Mediaroom set-up-box on the network."""
def set_state(self, mediaroom_state):
"""Map pymediaroom state to HA state."""
from pymediaroom import State
state_map = {
State.OFF: STATE_OFF,
State.STANDBY: STATE_STANDBY,
State.PLAYING_LIVE_TV: STATE_PLAYING,
State.PLAYING_RECORDED_TV: STATE_PLAYING,
State.PLAYING_TIMESHIFT_TV: STATE_PLAYING,
State.STOPPED: STATE_PAUSED,
State.UNKNOWN: STATE_UNAVAILABLE
}
self._state = state_map[mediaroom_state]
def __init__(
self, host, device_id, optimistic=False, timeout=DEFAULT_TIMEOUT):
"""Initialize the device."""
from pymediaroom import Remote
self.host = host
self.stb = Remote(host)
_LOGGER.info("Found STB at %s%s", host,
" - I'm optimistic" if optimistic else "")
self._channel = None
self._optimistic = optimistic
self._state = STATE_PLAYING if optimistic else STATE_STANDBY
self._name = 'Mediaroom {}'.format(device_id if device_id else host)
self._available = True
if device_id:
self._unique_id = device_id
else:
self._unique_id = None
@property
def should_poll(self):
"""No polling needed."""
return False
@property
def available(self):
"""Return True if entity is available."""
return self._available
async def async_added_to_hass(self):
"""Retrieve latest state."""
async def async_notify_received(notify):
"""Process STB state from NOTIFY message."""
stb_state = self.stb.notify_callback(notify)
# stb_state is None in case the notify is not from the current stb
if not stb_state:
return
self.set_state(stb_state)
_LOGGER.debug("STB(%s) is [%s]", self.host, self._state)
self._available = True
self.async_schedule_update_ha_state()
async_dispatcher_connect(
self.hass, SIGNAL_STB_NOTIFY, async_notify_received)
async def async_play_media(self, media_type, media_id, **kwargs):
"""Play media."""
from pymediaroom import PyMediaroomError
_LOGGER.debug("STB(%s) Play media: %s (%s)", self.stb.stb_ip,
media_id, media_type)
if media_type != MEDIA_TYPE_CHANNEL:
_LOGGER.error('invalid media type')
return
if not media_id.isdigit():
_LOGGER.error("media_id must be a channel number")
return
try:
await self.stb.send_cmd(int(media_id))
if self._optimistic:
self._state = STATE_PLAYING
self._available = True
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
@property
def unique_id(self):
"""Return a unique ID."""
return self._unique_id
@property
def name(self):
"""Return the name of the device."""
return self._name
@property
def state(self):
"""Return the state of the device."""
return self._state
@property
def supported_features(self):
"""Flag media player features that are supported."""
return SUPPORT_MEDIAROOM
@property
def media_content_type(self):
"""Return the content type of current playing media."""
return MEDIA_TYPE_CHANNEL
@property
def media_channel(self):
"""Channel currently playing."""
return self._channel
async def async_turn_on(self):
"""Turn on the receiver."""
from pymediaroom import PyMediaroomError
try:
self.set_state(await self.stb.turn_on())
if self._optimistic:
self._state = STATE_PLAYING
self._available = True
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
async def async_turn_off(self):
"""Turn off the receiver."""
from pymediaroom import PyMediaroomError
try:
self.set_state(await self.stb.turn_off())
if self._optimistic:
self._state = STATE_STANDBY
self._available = True
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
async def async_media_play(self):
"""Send play command."""
from pymediaroom import PyMediaroomError
try:
_LOGGER.debug("media_play()")
await self.stb.send_cmd('PlayPause')
if self._optimistic:
self._state = STATE_PLAYING
self._available = True
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
async def async_media_pause(self):
"""Send pause command."""
from pymediaroom import PyMediaroomError
try:
await self.stb.send_cmd('PlayPause')
if self._optimistic:
self._state = STATE_PAUSED
self._available = True
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
async def async_media_stop(self):
"""Send stop command."""
from pymediaroom import PyMediaroomError
try:
await self.stb.send_cmd('Stop')
if self._optimistic:
self._state = STATE_PAUSED
self._available = True
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
async def async_media_previous_track(self):
"""Send Program Down command."""
from pymediaroom import PyMediaroomError
try:
await self.stb.send_cmd('ProgDown')
if self._optimistic:
self._state = STATE_PLAYING
self._available = True
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
async def async_media_next_track(self):
"""Send Program Up command."""
from pymediaroom import PyMediaroomError
try:
await self.stb.send_cmd('ProgUp')
if self._optimistic:
self._state = STATE_PLAYING
self._available = True
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
async def async_volume_up(self):
"""Send volume up command."""
from pymediaroom import PyMediaroomError
try:
await self.stb.send_cmd('VolUp')
self._available = True
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
async def async_volume_down(self):
"""Send volume up command."""
from pymediaroom import PyMediaroomError
try:
await self.stb.send_cmd('VolDown')
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
async def async_mute_volume(self, mute):
"""Send mute command."""
from pymediaroom import PyMediaroomError
try:
await self.stb.send_cmd('Mute')
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
class MediaroomDevice(MediaPlayerEntity):
"""Representation of a Mediaroom set-up-box on the network."""
_attr_should_poll = False
_attr_supported_features = (MediaPlayerEntityFeature.PAUSE
| MediaPlayerEntityFeature.TURN_ON
| MediaPlayerEntityFeature.TURN_OFF
| MediaPlayerEntityFeature.VOLUME_STEP
| MediaPlayerEntityFeature.VOLUME_MUTE
| MediaPlayerEntityFeature.PLAY_MEDIA
| MediaPlayerEntityFeature.STOP
| MediaPlayerEntityFeature.NEXT_TRACK
| MediaPlayerEntityFeature.PREVIOUS_TRACK
| MediaPlayerEntityFeature.PLAY)
def set_state(self, mediaroom_state):
"""Map pymediaroom state to HA state."""
state_map = {
State.OFF: STATE_OFF,
State.STANDBY: STATE_STANDBY,
State.PLAYING_LIVE_TV: STATE_PLAYING,
State.PLAYING_RECORDED_TV: STATE_PLAYING,
State.PLAYING_TIMESHIFT_TV: STATE_PLAYING,
State.STOPPED: STATE_PAUSED,
State.UNKNOWN: STATE_UNAVAILABLE,
}
self._state = state_map[mediaroom_state]
def __init__(self,
host,
device_id,
optimistic=False,
timeout=DEFAULT_TIMEOUT):
"""Initialize the device."""
self.host = host
self.stb = Remote(host)
_LOGGER.info("Found STB at %s%s", host,
" - I'm optimistic" if optimistic else "")
self._channel = None
self._optimistic = optimistic
self._state = STATE_PLAYING if optimistic else STATE_STANDBY
self._name = f"Mediaroom {device_id if device_id else host}"
self._available = True
if device_id:
self._unique_id = device_id
else:
self._unique_id = None
@property
def available(self):
"""Return True if entity is available."""
return self._available
async def async_added_to_hass(self):
"""Retrieve latest state."""
async def async_notify_received(notify):
"""Process STB state from NOTIFY message."""
stb_state = self.stb.notify_callback(notify)
# stb_state is None in case the notify is not from the current stb
if not stb_state:
return
self.set_state(stb_state)
_LOGGER.debug("STB(%s) is [%s]", self.host, self._state)
self._available = True
self.async_write_ha_state()
self.async_on_remove(
async_dispatcher_connect(self.hass, SIGNAL_STB_NOTIFY,
async_notify_received))
async def async_play_media(self, media_type, media_id, **kwargs):
"""Play media."""
_LOGGER.debug("STB(%s) Play media: %s (%s)", self.stb.stb_ip, media_id,
media_type)
if media_type == MEDIA_TYPE_CHANNEL:
if not media_id.isdigit():
_LOGGER.error("Invalid media_id %s: Must be a channel number",
media_id)
return
media_id = int(media_id)
elif media_type == MEDIA_TYPE_MEDIAROOM:
if media_id not in COMMANDS:
_LOGGER.error("Invalid media_id %s: Must be a command",
media_id)
return
else:
_LOGGER.error("Invalid media type %s", media_type)
return
try:
await self.stb.send_cmd(media_id)
if self._optimistic:
self._state = STATE_PLAYING
self._available = True
except PyMediaroomError:
self._available = False
self.async_write_ha_state()
@property
def unique_id(self):
"""Return a unique ID."""
return self._unique_id
@property
def name(self):
"""Return the name of the device."""
return self._name
@property
def state(self):
"""Return the state of the device."""
return self._state
@property
def media_content_type(self):
"""Return the content type of current playing media."""
return MEDIA_TYPE_CHANNEL
@property
def media_channel(self):
"""Channel currently playing."""
return self._channel
async def async_turn_on(self):
"""Turn on the receiver."""
try:
self.set_state(await self.stb.turn_on())
if self._optimistic:
self._state = STATE_PLAYING
self._available = True
except PyMediaroomError:
self._available = False
self.async_write_ha_state()
async def async_turn_off(self):
"""Turn off the receiver."""
try:
self.set_state(await self.stb.turn_off())
if self._optimistic:
self._state = STATE_STANDBY
self._available = True
except PyMediaroomError:
self._available = False
self.async_write_ha_state()
async def async_media_play(self):
"""Send play command."""
try:
_LOGGER.debug("media_play()")
await self.stb.send_cmd("PlayPause")
if self._optimistic:
self._state = STATE_PLAYING
self._available = True
except PyMediaroomError:
self._available = False
self.async_write_ha_state()
async def async_media_pause(self):
"""Send pause command."""
try:
await self.stb.send_cmd("PlayPause")
if self._optimistic:
self._state = STATE_PAUSED
self._available = True
except PyMediaroomError:
self._available = False
self.async_write_ha_state()
async def async_media_stop(self):
"""Send stop command."""
try:
await self.stb.send_cmd("Stop")
if self._optimistic:
self._state = STATE_PAUSED
self._available = True
except PyMediaroomError:
self._available = False
self.async_write_ha_state()
async def async_media_previous_track(self):
"""Send Program Down command."""
try:
await self.stb.send_cmd("ProgDown")
if self._optimistic:
self._state = STATE_PLAYING
self._available = True
except PyMediaroomError:
self._available = False
self.async_write_ha_state()
async def async_media_next_track(self):
"""Send Program Up command."""
try:
await self.stb.send_cmd("ProgUp")
if self._optimistic:
self._state = STATE_PLAYING
self._available = True
except PyMediaroomError:
self._available = False
self.async_write_ha_state()
async def async_volume_up(self):
"""Send volume up command."""
try:
await self.stb.send_cmd("VolUp")
self._available = True
except PyMediaroomError:
self._available = False
self.async_write_ha_state()
async def async_volume_down(self):
"""Send volume up command."""
try:
await self.stb.send_cmd("VolDown")
except PyMediaroomError:
self._available = False
self.async_write_ha_state()
async def async_mute_volume(self, mute):
"""Send mute command."""
try:
await self.stb.send_cmd("Mute")
except PyMediaroomError:
self._available = False
self.async_write_ha_state()
class MediaroomDevice(MediaPlayerDevice):
"""Representation of a Mediaroom set-up-box on the network."""
def __init__(self, name, host, optimistic=False, timeout=DEFAULT_TIMEOUT):
"""Initialize the device."""
from pymediaroom import Remote
self.stb = Remote(host, timeout=timeout)
_LOGGER.info("Found %s at %s%s", name, host,
" - I'm optimistic" if optimistic else "")
self._name = name
self._is_standby = not optimistic
self._current = None
self._optimistic = optimistic
self._state = STATE_STANDBY
def update(self):
"""Retrieve latest state."""
if not self._optimistic:
self._is_standby = self.stb.get_standby()
if self._is_standby:
self._state = STATE_STANDBY
elif self._state not in [STATE_PLAYING, STATE_PAUSED]:
self._state = STATE_PLAYING
_LOGGER.debug("%s(%s) is [%s]", self._name, self.stb.stb_ip,
self._state)
def play_media(self, media_type, media_id, **kwargs):
"""Play media."""
_LOGGER.debug("%s(%s) Play media: %s (%s)", self._name,
self.stb.stb_ip, media_id, media_type)
if media_type != MEDIA_TYPE_CHANNEL:
_LOGGER.error('invalid media type')
return
if media_id.isdigit():
media_id = int(media_id)
else:
return
self.stb.send_cmd(media_id)
self._state = STATE_PLAYING
@property
def name(self):
"""Return the name of the device."""
return self._name
# MediaPlayerDevice properties and methods
@property
def state(self):
"""Return the state of the device."""
return self._state
@property
def supported_features(self):
"""Flag media player features that are supported."""
return SUPPORT_MEDIAROOM
@property
def media_content_type(self):
"""Return the content type of current playing media."""
return MEDIA_TYPE_CHANNEL
def turn_on(self):
"""Turn on the receiver."""
self.stb.send_cmd('Power')
self._state = STATE_ON
def turn_off(self):
"""Turn off the receiver."""
self.stb.send_cmd('Power')
self._state = STATE_STANDBY
def media_play(self):
"""Send play command."""
_LOGGER.debug("media_play()")
self.stb.send_cmd('PlayPause')
self._state = STATE_PLAYING
def media_pause(self):
"""Send pause command."""
self.stb.send_cmd('PlayPause')
self._state = STATE_PAUSED
def media_stop(self):
"""Send stop command."""
self.stb.send_cmd('Stop')
self._state = STATE_PAUSED
def media_previous_track(self):
"""Send Program Down command."""
self.stb.send_cmd('ProgDown')
self._state = STATE_PLAYING
def media_next_track(self):
"""Send Program Up command."""
self.stb.send_cmd('ProgUp')
self._state = STATE_PLAYING
def volume_up(self):
"""Send volume up command."""
self.stb.send_cmd('VolUp')
def volume_down(self):
"""Send volume up command."""
self.stb.send_cmd('VolDown')
def mute_volume(self, mute):
"""Send mute command."""
self.stb.send_cmd('Mute')
class MediaroomDevice(MediaPlayerDevice):
"""Representation of a Mediaroom set-up-box on the network."""
def set_state(self, mediaroom_state):
"""Helper method to map pymediaroom states to HA states."""
from pymediaroom import State
state_map = {
State.OFF: STATE_OFF,
State.STANDBY: STATE_STANDBY,
State.PLAYING_LIVE_TV: STATE_PLAYING,
State.PLAYING_RECORDED_TV: STATE_PLAYING,
State.PLAYING_TIMESHIFT_TV: STATE_PLAYING,
State.STOPPED: STATE_PAUSED,
State.UNKNOWN: STATE_UNAVAILABLE
}
self._state = state_map[mediaroom_state]
def __init__(self,
host,
device_id,
optimistic=False,
timeout=DEFAULT_TIMEOUT):
"""Initialize the device."""
from pymediaroom import Remote
self.host = host
self.stb = Remote(host)
_LOGGER.info("Found STB at %s%s", host,
" - I'm optimistic" if optimistic else "")
self._channel = None
self._optimistic = optimistic
self._state = STATE_PLAYING if optimistic else STATE_STANDBY
self._name = 'Mediaroom {}'.format(device_id if device_id else host)
self._available = True
if device_id:
self._unique_id = device_id
else:
self._unique_id = None
@property
def should_poll(self):
"""No polling needed."""
return False
@property
def available(self):
"""Return True if entity is available."""
return self._available
async def async_added_to_hass(self):
"""Retrieve latest state."""
async def async_notify_received(notify):
"""Process STB state from NOTIFY message."""
stb_state = self.stb.notify_callback(notify)
# stb_state is None in case the notify is not from the current stb
if not stb_state:
return
self.set_state(stb_state)
_LOGGER.debug("STB(%s) is [%s]", self.host, self._state)
self._available = True
self.async_schedule_update_ha_state()
async_dispatcher_connect(self.hass, SIGNAL_STB_NOTIFY,
async_notify_received)
async def async_play_media(self, media_type, media_id, **kwargs):
"""Play media."""
from pymediaroom import PyMediaroomError
_LOGGER.debug("STB(%s) Play media: %s (%s)", self.stb.stb_ip, media_id,
media_type)
if media_type != MEDIA_TYPE_CHANNEL:
_LOGGER.error('invalid media type')
return
if not media_id.isdigit():
_LOGGER.error("media_id must be a channel number")
return
try:
await self.stb.send_cmd(int(media_id))
if self._optimistic:
self._state = STATE_PLAYING
self._available = True
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
@property
def unique_id(self):
"""Return a unique ID."""
return self._unique_id
@property
def name(self):
"""Return the name of the device."""
return self._name
@property
def state(self):
"""Return the state of the device."""
return self._state
@property
def supported_features(self):
"""Flag media player features that are supported."""
return SUPPORT_MEDIAROOM
@property
def media_content_type(self):
"""Return the content type of current playing media."""
return MEDIA_TYPE_CHANNEL
@property
def media_channel(self):
"""Channel currently playing."""
return self._channel
async def async_turn_on(self):
"""Turn on the receiver."""
from pymediaroom import PyMediaroomError
try:
self.set_state(await self.stb.turn_on())
if self._optimistic:
self._state = STATE_PLAYING
self._available = True
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
async def async_turn_off(self):
"""Turn off the receiver."""
from pymediaroom import PyMediaroomError
try:
self.set_state(await self.stb.turn_off())
if self._optimistic:
self._state = STATE_STANDBY
self._available = True
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
async def async_media_play(self):
"""Send play command."""
from pymediaroom import PyMediaroomError
try:
_LOGGER.debug("media_play()")
await self.stb.send_cmd('PlayPause')
if self._optimistic:
self._state = STATE_PLAYING
self._available = True
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
async def async_media_pause(self):
"""Send pause command."""
from pymediaroom import PyMediaroomError
try:
await self.stb.send_cmd('PlayPause')
if self._optimistic:
self._state = STATE_PAUSED
self._available = True
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
async def async_media_stop(self):
"""Send stop command."""
from pymediaroom import PyMediaroomError
try:
await self.stb.send_cmd('Stop')
if self._optimistic:
self._state = STATE_PAUSED
self._available = True
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
async def async_media_previous_track(self):
"""Send Program Down command."""
from pymediaroom import PyMediaroomError
try:
await self.stb.send_cmd('ProgDown')
if self._optimistic:
self._state = STATE_PLAYING
self._available = True
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
async def async_media_next_track(self):
"""Send Program Up command."""
from pymediaroom import PyMediaroomError
try:
await self.stb.send_cmd('ProgUp')
if self._optimistic:
self._state = STATE_PLAYING
self._available = True
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
async def async_volume_up(self):
"""Send volume up command."""
from pymediaroom import PyMediaroomError
try:
await self.stb.send_cmd('VolUp')
self._available = True
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
async def async_volume_down(self):
"""Send volume up command."""
from pymediaroom import PyMediaroomError
try:
await self.stb.send_cmd('VolDown')
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
async def async_mute_volume(self, mute):
"""Send mute command."""
from pymediaroom import PyMediaroomError
try:
await self.stb.send_cmd('Mute')
except PyMediaroomError:
self._available = False
self.async_schedule_update_ha_state()
class MediaroomDevice(MediaPlayerDevice):
"""Representation of a Mediaroom set-up-box on the network."""
def __init__(self, name, host, optimistic=False, timeout=DEFAULT_TIMEOUT):
"""Initialize the device."""
from pymediaroom import Remote
self.stb = Remote(host, timeout=timeout)
_LOGGER.info(
"Found %s at %s%s", name, host,
" - I'm optimistic" if optimistic else "")
self._name = name
self._is_standby = not optimistic
self._current = None
self._optimistic = optimistic
self._state = STATE_STANDBY
def update(self):
"""Retrieve latest state."""
if not self._optimistic:
self._is_standby = self.stb.get_standby()
if self._is_standby:
self._state = STATE_STANDBY
elif self._state not in [STATE_PLAYING, STATE_PAUSED]:
self._state = STATE_PLAYING
_LOGGER.debug(
"%s(%s) is [%s]",
self._name, self.stb.stb_ip, self._state)
def play_media(self, media_type, media_id, **kwargs):
"""Play media."""
_LOGGER.debug(
"%s(%s) Play media: %s (%s)",
self._name, self.stb.stb_ip, media_id, media_type)
if media_type != MEDIA_TYPE_CHANNEL:
_LOGGER.error('invalid media type')
return
if media_id.isdigit():
media_id = int(media_id)
else:
return
self.stb.send_cmd(media_id)
self._state = STATE_PLAYING
@property
def name(self):
"""Return the name of the device."""
return self._name
# MediaPlayerDevice properties and methods
@property
def state(self):
"""Return the state of the device."""
return self._state
@property
def supported_features(self):
"""Flag media player features that are supported."""
return SUPPORT_MEDIAROOM
@property
def media_content_type(self):
"""Return the content type of current playing media."""
return MEDIA_TYPE_CHANNEL
def turn_on(self):
"""Turn on the receiver."""
self.stb.send_cmd('Power')
self._state = STATE_ON
def turn_off(self):
"""Turn off the receiver."""
self.stb.send_cmd('Power')
self._state = STATE_STANDBY
def media_play(self):
"""Send play command."""
_LOGGER.debug("media_play()")
self.stb.send_cmd('PlayPause')
self._state = STATE_PLAYING
def media_pause(self):
"""Send pause command."""
self.stb.send_cmd('PlayPause')
self._state = STATE_PAUSED
def media_stop(self):
"""Send stop command."""
self.stb.send_cmd('Stop')
self._state = STATE_PAUSED
def media_previous_track(self):
"""Send Program Down command."""
self.stb.send_cmd('ProgDown')
self._state = STATE_PLAYING
def media_next_track(self):
"""Send Program Up command."""
self.stb.send_cmd('ProgUp')
self._state = STATE_PLAYING
def volume_up(self):
"""Send volume up command."""
self.stb.send_cmd('VolUp')
def volume_down(self):
"""Send volume up command."""
self.stb.send_cmd('VolDown')
def mute_volume(self, mute):
"""Send mute command."""
self.stb.send_cmd('Mute')
