Wake on LAN for UI-configured Samsung TVs

homeassistant/components/samsungtv/__init__.py

@@ -9,6 +9,8 @@
 
 from .const import CONF_ON_ACTION, DEFAULT_NAME, DOMAIN
 
+UNDO_UPDATE_LISTENER = "update_update_listener"
+
 
 def ensure_unique_hosts(value):
     """Validate that all configs have a unique host."""
@@ -62,8 +64,33 @@ async def async_setup(hass, config):
 
 async def async_setup_entry(hass, entry):
     """Set up the Samsung TV platform."""
+    undo_listener = entry.add_update_listener(_update_listener)
+
+    hass.data.setdefault(DOMAIN, {})
+    hass.data[DOMAIN][entry.entry_id] = {
+        UNDO_UPDATE_LISTENER: undo_listener,
+    }
+
     hass.async_create_task(
         hass.config_entries.async_forward_entry_setup(entry, MP_DOMAIN)
     )
 
     return True
+
+
+async def async_unload_entry(hass, entry):
+    """Unload a config entry."""
+    unload_ok = await hass.async_create_task(
+        hass.config_entries.async_forward_entry_unload(entry, MP_DOMAIN)
+    )
+
+    if unload_ok:
+        hass.data[DOMAIN][entry.entry_id][UNDO_UPDATE_LISTENER]()
+        hass.data[DOMAIN].pop(entry.entry_id)
+
+    return unload_ok
+
+
+async def _update_listener(hass, entry):
+    """Handle options update."""
+    await hass.config_entries.async_reload(entry.entry_id)

homeassistant/components/samsungtv/config_flow.py

@@ -1,10 +1,12 @@
 """Config flow for Samsung TV."""
+from functools import partial
 import socket
 from urllib.parse import urlparse
 
+from getmac import get_mac_address
 import voluptuous as vol
 
-from homeassistant import config_entries
+from homeassistant import config_entries, core
 from homeassistant.components.ssdp import (
     ATTR_SSDP_LOCATION,
     ATTR_UPNP_MANUFACTURER,
@@ -15,6 +17,7 @@
     CONF_HOST,
     CONF_ID,
     CONF_IP_ADDRESS,
+    CONF_MAC,
     CONF_METHOD,
     CONF_NAME,
     CONF_PORT,
@@ -174,3 +177,41 @@ async def async_step_reauth(self, user_input=None):
         self.context["title_placeholders"] = {"model": self._title}
 
         return await self.async_step_confirm()
+
+    @staticmethod
+    @core.callback
+    def async_get_options_flow(config_entry):
+        """Define the config flow to handle options."""
+        return SamsungTVOptionsFlowHandler(config_entry)
+
+
+class SamsungTVOptionsFlowHandler(config_entries.OptionsFlow):
+    """Handle a SamsungTV options flow."""
+
+    def __init__(self, config_entry):
+        """Initialize."""
+        self.config_entry = config_entry
+
+    async def async_step_init(self, user_input=None):
+        """Manage the options."""
+        if user_input is not None:
+            if CONF_MAC not in user_input or user_input[CONF_MAC].strip() == "":
+                user_input.pop(CONF_MAC, None)
+            return self.async_create_entry(title="", data=user_input)
+
+        if CONF_MAC in self.config_entry.options:
+            current_mac = self.config_entry.options[CONF_MAC]
+        else:
+            hostname = self.config_entry.data[CONF_HOST]
+            try:
+                current_mac = await self.hass.async_add_executor_job(
+                    partial(get_mac_address, **{"hostname": hostname})
+                )
+            except OSError:
+                LOGGER.info("Could not find mac address for %s", hostname)
+                current_mac = ""
+
+        schema = {
+            vol.Optional(CONF_MAC, description={"suggested_value": current_mac}): str
+        }
+        return self.async_show_form(step_id="init", data_schema=vol.Schema(schema))

homeassistant/components/samsungtv/manifest.json

@@ -4,7 +4,8 @@
   "documentation": "https://www.home-assistant.io/integrations/samsungtv",
   "requirements": [
     "samsungctl[websocket]==0.7.1",
-    "samsungtvws[websocket]==1.4.0"
+    "samsungtvws[websocket]==1.4.0",
+    "getmac==0.8.2"
   ],
   "ssdp": [
     {

homeassistant/components/samsungtv/media_player.py

@@ -4,6 +4,7 @@
 
 import voluptuous as vol
 
+from homeassistant import core
 from homeassistant.components.media_player import DEVICE_CLASS_TV, MediaPlayerEntity
 from homeassistant.components.media_player.const import (
     MEDIA_TYPE_CHANNEL,
@@ -22,9 +23,12 @@
     CONF_HOST,
     CONF_ID,
     CONF_IP_ADDRESS,
+    CONF_MAC,
     CONF_METHOD,
     CONF_NAME,
     CONF_PORT,
+    CONF_SERVICE,
+    CONF_SERVICE_DATA,
     CONF_TOKEN,
     STATE_OFF,
     STATE_ON,
@@ -52,11 +56,27 @@
 )
 
 
+@core.callback
+def async_get_on_script_from_mac(hass, mac):
+    """Create an on script from a mac address."""
+    script = cv.SCRIPT_SCHEMA(
+        {
+            CONF_SERVICE: "wake_on_lan.send_magic_packet",
+            CONF_SERVICE_DATA: {CONF_MAC: mac},
+        }
+    )
+    return Script(hass, script)
+
+
 async def async_setup_entry(hass, config_entry, async_add_entities):
     """Set up the Samsung TV from a config entry."""
     ip_address = config_entry.data[CONF_IP_ADDRESS]
     on_script = None
-    if (
+
+    if CONF_MAC in config_entry.options:
+        mac = config_entry.options[CONF_MAC]
+        on_script = async_get_on_script_from_mac(hass, mac)
+    elif (
         DOMAIN in hass.data
         and ip_address in hass.data[DOMAIN]
         and CONF_ON_ACTION in hass.data[DOMAIN][ip_address]

homeassistant/components/samsungtv/strings.json

@@ -18,5 +18,15 @@
       "not_successful": "Unable to connect to this Samsung TV device.",
       "not_supported": "This Samsung TV device is currently not supported."
     }
+  },
+  "options": {
+    "step": {
+      "init": {
+        "title": "Configure MAC address",
+        "data": {
+          "mac": "MAC address"
+        }
+      }
+    }
   }
 }

requirements_all.txt

@@ -620,6 +620,7 @@ georss_qld_bushfire_alert_client==0.3
 # homeassistant.components.kef
 # homeassistant.components.minecraft_server
 # homeassistant.components.nmap_tracker
+# homeassistant.components.samsungtv
 getmac==0.8.2
 
 # homeassistant.components.gios

requirements_test_all.txt

@@ -255,6 +255,7 @@ georss_qld_bushfire_alert_client==0.3
 # homeassistant.components.kef
 # homeassistant.components.minecraft_server
 # homeassistant.components.nmap_tracker
+# homeassistant.components.samsungtv
 getmac==0.8.2
 
 # homeassistant.components.gios

tests/components/samsungtv/test_config_flow.py

@@ -1,4 +1,6 @@
 """Tests for Samsung TV config flow."""
+import socket
+
 import pytest
 from samsungctl.exceptions import AccessDenied, UnhandledResponse
 from samsungtvws.exceptions import ConnectionFailure
@@ -16,9 +18,17 @@
     ATTR_UPNP_MODEL_NAME,
     ATTR_UPNP_UDN,
 )
-from homeassistant.const import CONF_HOST, CONF_ID, CONF_METHOD, CONF_NAME, CONF_TOKEN
+from homeassistant.const import (
+    CONF_HOST,
+    CONF_ID,
+    CONF_MAC,
+    CONF_METHOD,
+    CONF_NAME,
+    CONF_TOKEN,
+)
 
 from tests.async_mock import DEFAULT as DEFAULT_MOCK, Mock, PropertyMock, call, patch
+from tests.common import MockConfigEntry
 
 MOCK_USER_DATA = {CONF_HOST: "fake_host", CONF_NAME: "fake_name"}
 MOCK_SSDP_DATA = {
@@ -571,3 +581,92 @@ async def test_autodetect_none(hass, remote, remotews):
             call(**AUTODETECT_WEBSOCKET_PLAIN),
             call(**AUTODETECT_WEBSOCKET_SSL),
         ]
+
+
+async def test_options_with_obtained_mac(hass, remote):
+    """Test the options flow with obtained mac."""
+    config_entry = MockConfigEntry(domain=DOMAIN, data={CONF_HOST: "hostname"},)
+
+    config_entry.add_to_hass(hass)
+
+    # by default, the mac address should be automatically obtained
+    with patch(
+        "homeassistant.components.samsungtv.config_flow.get_mac_address",
+        return_value="11:11:11",
+    ):
+        result = await hass.config_entries.options.async_init(config_entry.entry_id)
+
+    assert result["type"] == "form"
+    assert result["step_id"] == "init"
+
+    result = await hass.config_entries.options.async_configure(
+        result["flow_id"], user_input={},
+    )
+
+    assert result["type"] == "create_entry"
+    assert config_entry.options.get(CONF_MAC) is None
+
+    # override the auto-obtained mac address
+    result = await hass.config_entries.options.async_init(config_entry.entry_id)
+
+    result = await hass.config_entries.options.async_configure(
+        result["flow_id"], user_input={CONF_MAC: "22:22:22"},
+    )
+    assert result["type"] == "create_entry"
+    assert config_entry.options[CONF_MAC] == "22:22:22"
+
+
+async def test_options_without_obtained_mac(hass, remote):
+    """Test the options flow without obtained mac."""
+    config_entry = MockConfigEntry(domain=DOMAIN, data={CONF_HOST: "hostname"},)
+
+    config_entry.add_to_hass(hass)
+
+    # simulate an error in getting the mac address
+    with patch(
+        "homeassistant.components.samsungtv.config_flow.get_mac_address",
+        side_effect=socket.gaierror(),
+    ):
+        result = await hass.config_entries.options.async_init(config_entry.entry_id)
+
+    assert result["type"] == "form"
+    assert result["step_id"] == "init"
+
+    result = await hass.config_entries.options.async_configure(
+        result["flow_id"], user_input={},
+    )
+
+    assert result["type"] == "create_entry"
+    assert config_entry.options.get(CONF_MAC) is None
+
+    result = await hass.config_entries.options.async_init(config_entry.entry_id)
+
+    result = await hass.config_entries.options.async_configure(
+        result["flow_id"], user_input={CONF_MAC: "22:22:22"},
+    )
+    assert result["type"] == "create_entry"
+    assert config_entry.options[CONF_MAC] == "22:22:22"
+
+
+async def test_options_with_empty_mac(hass, remote):
+    """Test the options flow with an empty string for mac."""
+    config_entry = MockConfigEntry(domain=DOMAIN, data={CONF_HOST: "hostname"},)
+
+    config_entry.add_to_hass(hass)
+
+    # simulate an error in getting the mac address
+    with patch(
+        "homeassistant.components.samsungtv.config_flow.get_mac_address",
+        return_value="11:11:11",
+    ):
+        result = await hass.config_entries.options.async_init(config_entry.entry_id)
+
+    assert result["type"] == "form"
+    assert result["step_id"] == "init"
+
+    result = await hass.config_entries.options.async_configure(
+        result["flow_id"], user_input={CONF_MAC: " "},
+    )
+
+    assert result["type"] == "create_entry"
+    assert config_entry.options.get(CONF_MAC) is None

tests/components/samsungtv/test_media_player.py

@@ -25,7 +25,10 @@
     CONF_ON_ACTION,
     DOMAIN as SAMSUNGTV_DOMAIN,
 )
-from homeassistant.components.samsungtv.media_player import SUPPORT_SAMSUNGTV
+from homeassistant.components.samsungtv.media_player import (
+    SUPPORT_SAMSUNGTV,
+    async_get_on_script_from_mac,
+)
 from homeassistant.const import (
     ATTR_DEVICE_CLASS,
     ATTR_ENTITY_ID,
@@ -101,6 +104,8 @@
     "token": "abcde",
 }
 
+MOCK_OPTIONS = {"mac": "11:11:11"}
+
 ENTITY_ID_NOTURNON = f"{DOMAIN}.fake_noturnon"
 MOCK_CONFIG_NOTURNON = {
     SAMSUNGTV_DOMAIN: [
@@ -742,3 +747,53 @@ async def test_select_source_invalid_source(hass, remote):
         assert remote.control.call_count == 0
         assert remote.close.call_count == 0
         assert remote.call_count == 1
+
+
+async def test_on_script_from_mac(hass, remote):
+    """Test creation of on-script from mac address."""
+
+    result = async_get_on_script_from_mac(hass, "11:11:11")
+
+    assert len(result.sequence) == 1
+    assert result.sequence[0]["service"] == "wake_on_lan.send_magic_packet"
+    assert result.sequence[0]["data"] == {"mac": "11:11:11"}
+
+
+async def test_setup_with_options(hass, remote):
+    """Test setup with mac address in options."""
+    entity_id = f"{DOMAIN}.fake"
+    entry = MockConfigEntry(
+        domain=SAMSUNGTV_DOMAIN,
+        data=MOCK_ENTRY_WS,
+        unique_id=entity_id,
+        options=MOCK_OPTIONS,
+    )
+    entry.add_to_hass(hass)
+
+    with patch(
+        "homeassistant.components.samsungtv.media_player.async_get_on_script_from_mac"
+    ) as on_script:
+        await async_setup_component(hass, SAMSUNGTV_DOMAIN, {})
+        # await hass.config_entries.async_setup(entry.entry_id)
+        await hass.async_block_till_done()
+
+        assert on_script.call_count == 1
+        assert on_script.call_args_list == [call(hass, MOCK_OPTIONS["mac"])]
+
+
+async def test_setup_without_options(hass, remote):
+    """Test setup without mac address in options."""
+    entity_id = f"{DOMAIN}.fake"
+    entry = MockConfigEntry(
+        domain=SAMSUNGTV_DOMAIN, data=MOCK_ENTRY_WS, unique_id=entity_id
+    )
+    entry.add_to_hass(hass)
+
+    with patch(
+        "homeassistant.components.samsungtv.media_player.async_get_on_script_from_mac"
+    ) as on_script:
+        await async_setup_component(hass, SAMSUNGTV_DOMAIN, {})
+        # await hass.config_entries.async_setup(entry.entry_id)
+        await hass.async_block_till_done()
+
+        assert on_script.call_count == 0