MediaRoom - Home Assistant Media Player Component

mediaroom.py

"""
Support for the Mediaroom Set-up-box.

WORK IN PROGRESS!!!

You need to place this file in ~/.homeassistant/custom_components/media_player
and install pymediaroom:

pip install pymediaroom

in your configuration, just add the platform:

media_player:
  - platform: mediaroom
    host: 192.168.1.64
    name: "vodafone STB"
    optimistic: True

If you don't type "host", auto discovery will look up a box in your network
"optimistic" will assure that the media player is enabled even if a status can't be retrieved

For more details about this platform, please refer to the documentation at
https://home-assistant.io/components/media_player.mediaroom/
"""
import voluptuous as vol

from homeassistant.components.media_player import (
    MEDIA_TYPE_CHANNEL, MEDIA_TYPE_VIDEO, SUPPORT_PAUSE, SUPPORT_PLAY_MEDIA,
    SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_STOP, PLATFORM_SCHEMA,
    SUPPORT_NEXT_TRACK, SUPPORT_PREVIOUS_TRACK, SUPPORT_PLAY,
    SUPPORT_VOLUME_STEP, SUPPORT_VOLUME_MUTE,
    MediaPlayerDevice)
from homeassistant.const import (
    CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON, CONF_OPTIMISTIC, CONF_TIMEOUT,
    STATE_IDLE, STATE_PAUSED, STATE_PLAYING, STATE_STANDBY)
import homeassistant.helpers.config_validation as cv
import logging
REQUIREMENTS = ['pymediaroom==0.5']

_LOGGER = logging.getLogger(__name__)

NOTIFICATION_TITLE = 'Mediaroom Media Player Setup'
NOTIFICATION_ID = 'mediaroom_notification'
DEFAULT_NAME = 'Mediaroom STB'
DEFAULT_TIMEOUT = 9 

KNOWN_HOSTS = []

SUPPORT_MEDIAROOM = SUPPORT_PAUSE | SUPPORT_TURN_ON | SUPPORT_TURN_OFF | \
    SUPPORT_VOLUME_STEP | SUPPORT_VOLUME_MUTE | \
    SUPPORT_PLAY_MEDIA | SUPPORT_STOP | SUPPORT_NEXT_TRACK | \
    SUPPORT_PREVIOUS_TRACK | SUPPORT_PLAY

PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_HOST): cv.string,
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
    vol.Optional(CONF_OPTIMISTIC, default=False): cv.boolean,
    vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int,
})

def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the Mediaroom platform."""
    hosts = []
    
    host = config.get(CONF_HOST, None)
    if host == None:
        _LOGGER.info("Trying to discover Mediaroom STB")
        
        from pymediaroom import Remote 

        host = Remote.discover(KNOWN_HOSTS)
        if host == None:
            #Can't find any STB
            return False 
    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)

    return True


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 {} at {}{}".format(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 not self._state in [STATE_PLAYING, STATE_PAUSED]:
            self._state = STATE_PLAYING
        _LOGGER.debug("{}({}) is [{}]".format(self._name, self.stb.stb_ip,self._state))

    def play_media(self, media_type, media_id, **kwargs):
        """Play media."""
        _LOGGER.debug("{}({}) Play media: {} ({})".format(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')

Hi Diogo,
I'm using the new firmware of MeoBox (sofia's flavour) and HA is giving me an error
2018-04-11 18:47:10 ERROR (MainThread) [homeassistant.core] Error doing job: Task exception was never retrieved Traceback (most recent call last): File "/usr/lib/python3.5/asyncio/tasks.py", line 239, in _step result = coro.send(None) File "/srv/homeassistant/lib/python3.5/site-packages/homeassistant/components/media_player/mediaroom.py", line 144, in async_notify_received stb_state = self.stb.notify_callback(notify) File "/srv/homeassistant/lib/python3.5/site-packages/pymediaroom/remote.py", line 119, in notify_callback self.tune_src = notify.tune['@src']
I've just copied as the HA component yaml

any help ?

This component has been superseded by https://www.home-assistant.io/components/media_player.mediaroom/

In the latest version 0.68 your issue is solved.