jvc.py

DOMAIN = 'media_player'

REQUIREMENTS = ['jvc_tools==0.1.3']

import logging
import voluptuous as vol
from homeassistant.helpers.entity import ToggleEntity

_LOGGER = logging.getLogger(__name__)

DEFAULT_NAME = 'Projector'
from homeassistant.components.media_player import (
    SUPPORT_SELECT_SOURCE, SUPPORT_TURN_OFF,
    SUPPORT_TURN_ON, MediaPlayerDevice)

SUPPORTED_FEATURES = SUPPORT_TURN_ON | SUPPORT_TURN_OFF #| SUPPORT_SELECT_SOURCE

#NORMAL_INPUTS = {'HDMI 1': 'HDMI1', 'HDMI 2': 'HDMI2'}

LOW_LATENCY_NAME = 'EnableLowLatency'
DEFAULT_LATENCY_VALUE = False

from homeassistant.const import (
    CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON, STATE_UNKNOWN)
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.config_validation import PLATFORM_SCHEMA

STATE_COOLING = 'Cooling'
STATE_STARTING = 'Starting'

PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_HOST): cv.string,
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
})

def setup_platform(hass, config, add_devices, discovery_info=None):
    _LOGGER.info('init projector platform') 
  
    import jvc_tools    
    host = config.get(CONF_HOST)
    name = config.get(CONF_NAME)
    _LOGGER.info('projector host %s', host)
    internal_projector = jvc_tools.JVCProjector(host=host)
    projector = JVCProjectorDevice(internal_projector, name)
    add_devices([projector])

    def handle_set_low_latency(call):
        enable_raw = call.data.get(LOW_LATENCY_NAME)
        _LOGGER.info('Raw: %2s', enable_raw)
        enable = call.data.get(LOW_LATENCY_NAME, DEFAULT_LATENCY_VALUE)
        if enable == 'True':
            projector.turn_on_low_latency()
        else:
            projector.turn_off_low_latency()

    hass.services.register(DOMAIN, 'set_low_latency', handle_set_low_latency)



class JVCProjectorDevice(MediaPlayerDevice):
    def __init__(self, projector, name=DEFAULT_NAME):
        _LOGGER.info('init for projector device')
        self._projector = projector                 
        self._name = name        
        #self._source_list = NORMAL_INPUTS.copy()
        #self._mediasource = ''
        self._input_info = STATE_UNKNOWN

    @property
    def name(self):
        """Return the name of the device."""
        return self._name

    @property 
    def state(self):        
        return self._projector.state
        
    # @property
    # def source(self):
    #     """Return the current input source."""
    #     for pretty_name, name in self._source_list.items():
    #         if self._mediasource == name:
    #             return pretty_name

    def turn_on(self):
        """Turn the media player on."""
        self._projector.turn_on()

    # def select_source(self, source):
    #     """Select input source."""
    #     _LOGGER.info('Pretending to select source')
    #     #self.telnet_command('SI' + self._source_list.get(source))
    
    def update(self):
        """Synchronize state with switch."""
        self._projector.update()

    # def _update(self, retry=2):
    #     try:
    #         with self._jvc as cmd:  
    #             _LOGGER.debug('Updating projector. Tries remaining: %d', retry)
    #             try:                    
    #                 self._powerState = cmd.get(Command.Power)
    #             except Exception as err:
    #                 if retry < 1:
    #                     _LOGGER.error("Exception getting power state:", err)  
    #                     return
    #                 return self._update(retry - 1)
    #             else:
    #                 _LOGGER.debug('Power on, reading other properties.')
    #                 self._lowLatencyState = None
    #                 if (self._powerState == PowerState.LampOn):
    #                     self._lowLatencyState = cmd.get(Command.LowLatency)            
    #     except CommandNack as err:
    #         if retry < 1:
    #             _LOGGER.error("NACK during update:", err)  
    #             return          
    #         return self._update(retry - 1)
    #     except Timeout as err:
    #         if retry < 1:
    #             _LOGGER.error("Timeout during update:", error)
    #             return
    #         return self._update(retry - 1)   
    #     except Exception as err:
    #         if retry < 1:
    #             _LOGGER.error("Generic error during update:", err)
    #             return             
    #         return self._update(retry - 1)

    @property
    def device_state_attributes(self):
        """Return the state attributes of the device."""
        attr = {}
        attr['low_latency_enabled'] = self._projector.low_latency_enabled
        attr['input_info'] = self._projector.input_info
        return attr

    @property
    def supported_features(self):
        """Flag media player features that are supported."""
        return SUPPORTED_FEATURES

    # @property
    # def source_list(self):
    #     """Return the list of available input sources."""
    #     return sorted(list(self._source_list.keys()))

    @property
    def is_low_latency_on(self):
        return self._projector.low_latency_enabled

    def turn_on_low_latency(self):
        """turn it on"""
        self._projector.low_latency_enabled = True

    def turn_off_low_latency(self):
        """turn it off"""
        self._projector.low_latency_enabled = False