Add samsungtv dhcp and zeroconf discovery

.coveragerc

@@ -866,6 +866,7 @@ omit =
     homeassistant/components/russound_rnet/media_player.py
     homeassistant/components/sabnzbd/*
     homeassistant/components/saj/sensor.py
+    homeassistant/components/samsungtv/bridge.py
     homeassistant/components/satel_integra/*
     homeassistant/components/schluter/*
     homeassistant/components/scrape/sensor.py

CODEOWNERS

@@ -410,7 +410,7 @@ homeassistant/components/rpi_power/* @shenxn @swetoast
 homeassistant/components/ruckus_unleashed/* @gabe565
 homeassistant/components/safe_mode/* @home-assistant/core
 homeassistant/components/saj/* @fredericvl
-homeassistant/components/samsungtv/* @escoand
+homeassistant/components/samsungtv/* @escoand @chemelli74
 homeassistant/components/scene/* @home-assistant/core
 homeassistant/components/schluter/* @prairieapps
 homeassistant/components/scrape/* @fabaff

homeassistant/components/samsungtv/__init__.py

@@ -5,20 +5,31 @@
 
 from homeassistant import config_entries
 from homeassistant.components.media_player.const import DOMAIN as MP_DOMAIN
-from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PORT
+from homeassistant.const import (
+    CONF_HOST,
+    CONF_METHOD,
+    CONF_NAME,
+    CONF_PORT,
+    CONF_TOKEN,
+    EVENT_HOMEASSISTANT_STOP,
+)
+from homeassistant.core import callback
 import homeassistant.helpers.config_validation as cv
 
-from .const import CONF_ON_ACTION, DEFAULT_NAME, DOMAIN
+from .bridge import SamsungTVBridge
+from .const import CONF_ON_ACTION, DEFAULT_NAME, DOMAIN, LOGGER
 
 
 def ensure_unique_hosts(value):
     """Validate that all configs have a unique host."""
     vol.Schema(vol.Unique("duplicate host entries found"))(
-        [socket.gethostbyname(entry[CONF_HOST]) for entry in value]
+        [entry[CONF_HOST] for entry in value]
     )
     return value
 
 
+PLATFORMS = [MP_DOMAIN]
+
 CONFIG_SCHEMA = vol.Schema(
     {
         DOMAIN: vol.All(
@@ -43,30 +54,87 @@ def ensure_unique_hosts(value):
 
 async def async_setup(hass, config):
     """Set up the Samsung TV integration."""
-    if DOMAIN in config:
-        hass.data[DOMAIN] = {}
-        for entry_config in config[DOMAIN]:
-            ip_address = await hass.async_add_executor_job(
-                socket.gethostbyname, entry_config[CONF_HOST]
-            )
-            hass.data[DOMAIN][ip_address] = {
-                CONF_ON_ACTION: entry_config.get(CONF_ON_ACTION)
-            }
-            hass.async_create_task(
-                hass.config_entries.flow.async_init(
-                    DOMAIN,
-                    context={"source": config_entries.SOURCE_IMPORT},
-                    data=entry_config,
-                )
-            )
+    hass.data[DOMAIN] = {}
+    if DOMAIN not in config:
+        return True
 
+    for entry_config in config[DOMAIN]:
+        ip_address = await hass.async_add_executor_job(
+            socket.gethostbyname, entry_config[CONF_HOST]
+        )
+        hass.data[DOMAIN][ip_address] = {
+            CONF_ON_ACTION: entry_config.get(CONF_ON_ACTION)
+        }
+        hass.async_create_task(
+            hass.config_entries.flow.async_init(
+                DOMAIN,
+                context={"source": config_entries.SOURCE_IMPORT},
+                data=entry_config,
+            )
+        )
     return True
 
 
+@callback
+def _async_get_device_bridge(data):
+    """Get device bridge."""
+    return SamsungTVBridge.get_bridge(
+        data[CONF_METHOD],
+        data[CONF_HOST],
+        data[CONF_PORT],
+        data.get(CONF_TOKEN),
+    )
+
+
 async def async_setup_entry(hass, entry):
     """Set up the Samsung TV platform."""
-    hass.async_create_task(
-        hass.config_entries.async_forward_entry_setup(entry, MP_DOMAIN)
+
+    # Initialize bridge
+    data = entry.data.copy()
+    bridge = _async_get_device_bridge(data)
+    if bridge.port is None and bridge.default_port is not None:
+        # For backward compat, set default port for websocket tv
+        data[CONF_PORT] = bridge.default_port
+        hass.config_entries.async_update_entry(entry, data=data)
+        bridge = _async_get_device_bridge(data)
+
+    def stop_bridge(event):
+        """Stop SamsungTV bridge connection."""
+        bridge.stop()
+
+    entry.async_on_unload(
+        hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, stop_bridge)
     )
 
+    hass.data[DOMAIN][entry.entry_id] = bridge
+    hass.config_entries.async_setup_platforms(entry, PLATFORMS)
+    return True
+
+
+async def async_unload_entry(hass, entry):
+    """Unload a config entry."""
+    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+    if unload_ok:
+        hass.data[DOMAIN][entry.entry_id].stop()
+    return unload_ok
+
+
+async def async_migrate_entry(hass, config_entry):
+    """Migrate old entry."""
+    version = config_entry.version
+
+    LOGGER.debug("Migrating from version %s", version)
+
+    # 1 -> 2: Unique ID format changed, so delete and re-import:
+    if version == 1:
+        dev_reg = await hass.helpers.device_registry.async_get_registry()
+        dev_reg.async_clear_config_entry(config_entry)
+
+        en_reg = await hass.helpers.entity_registry.async_get_registry()
+        en_reg.async_clear_config_entry(config_entry)
+
+        version = config_entry.version = 2
+        hass.config_entries.async_update_entry(config_entry)
+    LOGGER.debug("Migration to version %s successful", version)
+
     return True

homeassistant/components/samsungtv/bridge.py

@@ -1,10 +1,11 @@
 """samsungctl and samsungtvws bridge classes."""
 from abc import ABC, abstractmethod
+import contextlib
 
 from samsungctl import Remote
 from samsungctl.exceptions import AccessDenied, ConnectionClosed, UnhandledResponse
 from samsungtvws import SamsungTVWS
-from samsungtvws.exceptions import ConnectionFailure
+from samsungtvws.exceptions import ConnectionFailure, HttpApiError
 from websocket import WebSocketException
 
 from homeassistant.const import (
@@ -25,8 +26,11 @@
     RESULT_CANNOT_CONNECT,
     RESULT_NOT_SUPPORTED,
     RESULT_SUCCESS,
+    TIMEOUT_REQUEST,
+    TIMEOUT_WEBSOCKET,
     VALUE_CONF_ID,
     VALUE_CONF_NAME,
+    WEBSOCKET_PORTS,
 )
 
 
@@ -58,9 +62,14 @@ def register_reauth_callback(self, func):
     def try_connect(self):
         """Try to connect to the TV."""
 
+    @abstractmethod
+    def device_info(self):
+        """Try to gather infos of this TV."""
+
     def is_on(self):
         """Tells if the TV is on."""
-        self.close_remote()
+        if self._remote:
+            self.close_remote()
 
         try:
             return self._get_remote() is not None
@@ -104,7 +113,7 @@ def _send_key(self, key):
         """Send the key."""
 
     @abstractmethod
-    def _get_remote(self):
+    def _get_remote(self, avoid_open: bool = False):
         """Get Remote object."""
 
     def close_remote(self):
@@ -149,7 +158,7 @@ def try_connect(self):
             CONF_METHOD: self.method,
             CONF_PORT: None,
             # We need this high timeout because waiting for auth popup is just an open socket
-            CONF_TIMEOUT: 31,
+            CONF_TIMEOUT: TIMEOUT_REQUEST,
         }
         try:
             LOGGER.debug("Try config: %s", config)
@@ -162,11 +171,15 @@ def try_connect(self):
         except UnhandledResponse:
             LOGGER.debug("Working but unsupported config: %s", config)
             return RESULT_NOT_SUPPORTED
-        except OSError as err:
+        except (ConnectionClosed, OSError) as err:
             LOGGER.debug("Failing config: %s, error: %s", config, err)
             return RESULT_CANNOT_CONNECT
 
-    def _get_remote(self):
+    def device_info(self):
+        """Try to gather infos of this device."""
+        return None
+
+    def _get_remote(self, avoid_open: bool = False):
         """Create or return a remote control instance."""
         if self._remote is None:
             # We need to create a new instance to reconnect.
@@ -184,6 +197,11 @@ def _send_key(self, key):
         """Send the key using legacy protocol."""
         self._get_remote().control(key)
 
+    def stop(self):
+        """Stop Bridge."""
+        LOGGER.debug("Stopping SamsungRemote")
+        self.close_remote()
+
 
 class SamsungTVWSBridge(SamsungTVBridge):
     """The Bridge for WebSocket TVs."""
@@ -196,14 +214,14 @@ def __init__(self, method, host, port, token=None):
 
     def try_connect(self):
         """Try to connect to the Websocket TV."""
-        for self.port in (8001, 8002):
+        for self.port in WEBSOCKET_PORTS:
             config = {
                 CONF_NAME: VALUE_CONF_NAME,
                 CONF_HOST: self.host,
                 CONF_METHOD: self.method,
                 CONF_PORT: self.port,
                 # We need this high timeout because waiting for auth popup is just an open socket
-                CONF_TIMEOUT: 31,
+                CONF_TIMEOUT: TIMEOUT_REQUEST,
             }
 
             result = None
@@ -234,31 +252,46 @@ def try_connect(self):
 
         return RESULT_CANNOT_CONNECT
 
+    def device_info(self):
+        """Try to gather infos of this TV."""
+        remote = self._get_remote(avoid_open=True)
+        if not remote:
+            return None
+        with contextlib.suppress(HttpApiError):
+            return remote.rest_device_info()
+
     def _send_key(self, key):
         """Send the key using websocket protocol."""
         if key == "KEY_POWEROFF":
             key = "KEY_POWER"
         self._get_remote().send_key(key)
 
-    def _get_remote(self):
+    def _get_remote(self, avoid_open: bool = False):
         """Create or return a remote control instance."""
         if self._remote is None:
             # We need to create a new instance to reconnect.
             try:
-                LOGGER.debug("Create SamsungTVWS")
+                LOGGER.debug(
+                    "Create SamsungTVWS for %s (%s)", VALUE_CONF_NAME, self.host
+                )
                 self._remote = SamsungTVWS(
                     host=self.host,
                     port=self.port,
                     token=self.token,
-                    timeout=8,
+                    timeout=TIMEOUT_WEBSOCKET,
                     name=VALUE_CONF_NAME,
                 )
-                self._remote.open()
+                if not avoid_open:
+                    self._remote.open()
             # This is only happening when the auth was switched to DENY
             # A removed auth will lead to socket timeout because waiting for auth popup is just an open socket
             except ConnectionFailure:
                 self._notify_callback()
-                raise
-            except WebSocketException:
+            except (WebSocketException, OSError):
                 self._remote = None
         return self._remote
+
+    def stop(self):
+        """Stop Bridge."""
+        LOGGER.debug("Stopping SamsungTVWS")
+        self.close_remote()