Add option to LinkPlay to disregard HA hostname and use IP instead

homeassistant/components/linkplay/__init__.py

@@ -26,13 +26,20 @@ class LinkPlayData:
 
 type LinkPlayConfigEntry = ConfigEntry[LinkPlayData]
 
+async def options_update_listener(hass: HomeAssistant, entry: LinkPlayConfigEntry):
+    """Handle options update."""
+    await hass.config_entries.async_reload(entry.entry_id)
+
 
 async def async_setup_entry(hass: HomeAssistant, entry: LinkPlayConfigEntry) -> bool:
     """Async setup hass config entry. Called when an entry has been setup."""
 
     session: ClientSession = await async_get_client_session(hass)
     bridge: LinkPlayBridge | None = None
 
+    # Register update listener to update config entry when options are updated.
+    entry.async_on_unload(entry.add_update_listener(options_update_listener))
+
     # try create a bridge
     try:
         bridge = await linkplay_factory_httpapi_bridge(entry.data[CONF_HOST], session)

homeassistant/components/linkplay/config_flow.py

@@ -9,15 +9,43 @@
 from linkplay.exceptions import LinkPlayRequestException
 import voluptuous as vol
 
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult, OptionsFlow, FlowResult, ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_MODEL
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
+from homeassistant.core import callback
 
-from .const import DOMAIN
+from .const import DOMAIN, CONF_USE_IP_URL
 from .utils import async_get_client_session
 
 _LOGGER = logging.getLogger(__name__)
 
+OPTIONS_SCHEMA=vol.Schema(
+    {
+        vol.Required(CONF_USE_IP_URL, default=False): bool,
+    }
+)
+
+class LinkPlayOptionsFlow(OptionsFlow):
+    """LinkPlay options flow."""
+
+    def __init__(self, config_entry: ConfigEntry) -> None:
+        self.config_entry = config_entry
+
+    async def async_step_init(
+        self, user_input: dict[str, Any] | None = None
+    ) -> FlowResult:
+        """LinkPlay options."""
+        if user_input is not None:
+            return self.async_create_entry(title="", data=user_input)
+
+        return self.async_show_form(
+            step_id="init",
+            data_schema=self.add_suggested_values_to_schema(
+                OPTIONS_SCHEMA, self.config_entry.options
+
+            ),
+        )
+
 
 class LinkPlayConfigFlow(ConfigFlow, domain=DOMAIN):
     """LinkPlay config flow."""
@@ -26,6 +54,14 @@ def __init__(self) -> None:
         """Initialize the LinkPlay config flow."""
         self.data: dict[str, Any] = {}
 
+    @staticmethod
+    @callback
+    def async_get_options_flow(
+        config_entry: ConfigEntry,
+    ) -> LinkPlayOptionsFlow:
+        """Create the options flow."""
+        return LinkPlayOptionsFlow(config_entry)
+
     async def async_step_zeroconf(
         self, discovery_info: ZeroconfServiceInfo
     ) -> ConfigFlowResult:

homeassistant/components/linkplay/const.py

@@ -10,3 +10,5 @@
 CONTROLLER_KEY: HassKey[LinkPlayController] = HassKey(CONTROLLER)
 PLATFORMS = [Platform.BUTTON, Platform.MEDIA_PLAYER]
 DATA_SESSION = "session"
+
+CONF_USE_IP_URL = "use_ip_url"

homeassistant/components/linkplay/media_player.py

@@ -10,6 +10,7 @@
 from linkplay.controller import LinkPlayController, LinkPlayMultiroom
 from linkplay.exceptions import LinkPlayRequestException
 import voluptuous as vol
+import yarl
 
 from homeassistant.components import media_source
 from homeassistant.components.media_player import (
@@ -31,10 +32,11 @@
     entity_registry as er,
 )
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.network import is_hass_url
 from homeassistant.util.dt import utcnow
 
 from . import LinkPlayConfigEntry, LinkPlayData
-from .const import CONTROLLER_KEY, DOMAIN
+from .const import CONTROLLER_KEY, DOMAIN, CONF_USE_IP_URL
 from .entity import LinkPlayBaseEntity, exception_wrap
 
 _LOGGER = logging.getLogger(__name__)
@@ -133,14 +135,17 @@ async def async_setup_entry(
 ) -> None:
     """Set up a media player from a config entry."""
 
+    config = hass.data[DOMAIN][entry.entry_id]
+    use_ip_url = entry.options.get(CONF_USE_IP_URL, False)
+
     # register services
     platform = entity_platform.async_get_current_platform()
     platform.async_register_entity_service(
         SERVICE_PLAY_PRESET, SERVICE_PLAY_PRESET_SCHEMA, "async_play_preset"
     )
 
     # add entities
-    async_add_entities([LinkPlayMediaPlayerEntity(entry.runtime_data.bridge)])
+    async_add_entities([LinkPlayMediaPlayerEntity(config=entry.runtime_data, use_ip_url=use_ip_url)])
 
 
 class LinkPlayMediaPlayerEntity(LinkPlayBaseEntity, MediaPlayerEntity):
@@ -151,14 +156,16 @@ class LinkPlayMediaPlayerEntity(LinkPlayBaseEntity, MediaPlayerEntity):
     _attr_media_content_type = MediaType.MUSIC
     _attr_name = None
 
-    def __init__(self, bridge: LinkPlayBridge) -> None:
+    def __init__(self, config: LinkPlayData, use_ip_url: bool = False) -> None:
         """Initialize the LinkPlay media player."""
 
-        super().__init__(bridge)
-        self._attr_unique_id = bridge.device.uuid
+        super().__init__(config.bridge)
+        self._attr_unique_id = config.bridge.device.uuid
+
+        self._use_ip_url = use_ip_url
 
         self._attr_source_list = [
-            SOURCE_MAP[playing_mode] for playing_mode in bridge.device.playmode_support
+            SOURCE_MAP[playing_mode] for playing_mode in config.bridge.device.playmode_support
         ]
 
     @exception_wrap
@@ -252,6 +259,14 @@ async def async_play_media(
             media_id = play_item.url
 
         url = async_process_play_media_url(self.hass, media_id)
+
+        # Modify the the url if required to use IP address instead of hostname.
+        # This is required for compatibility with some devices, but we only want to edit the URL if it is a HA URL.
+        if self._use_ip_url and is_hass_url(hass=self.hass, url=url):
+            parsed_url = yarl.URL(url)
+            # Update the parsed URL with the local ip
+            url = parsed_url.with_host(self.hass.config.api.local_ip)
+
         await self._bridge.player.play(url)
 
     @exception_wrap

homeassistant/components/linkplay/strings.json

@@ -23,6 +23,16 @@
       "unknown": "[%key:common::config_flow::error::unknown%]"
     }
   },
+  "options": {
+    "step": {
+      "init": {
+        "title": "LinkPlay options",
+        "data": {
+          "use_ip_url": "Force IP in Home Assistant generated URLs to work around bugs in using local domain names with some devices."
+        }
+      }
+    }
+  },
   "services": {
     "play_preset": {
       "name": "Play preset",

homeassistant/components/linkplay/utils.py

@@ -25,10 +25,12 @@
 MODELS_ARYLIC_A50: Final[str] = "A50"
 MODELS_ARYLIC_A50S: Final[str] = "A50+"
 MODELS_ARYLIC_UP2STREAM_AMP: Final[str] = "Up2Stream Amp 2.0"
+MODELS_ARYLIC_UP2STREAM_AMP_2P1: Final[str] = "Up2Stream Amp 2.1"
 MODELS_ARYLIC_UP2STREAM_AMP_V3: Final[str] = "Up2Stream Amp v3"
 MODELS_ARYLIC_UP2STREAM_AMP_V4: Final[str] = "Up2Stream Amp v4"
 MODELS_ARYLIC_UP2STREAM_PRO: Final[str] = "Up2Stream Pro v1"
 MODELS_ARYLIC_UP2STREAM_PRO_V3: Final[str] = "Up2Stream Pro v3"
+MODELS_ARYLIC_S10P: Final[str] = "Arylic S10+"
 MODELS_ARYLIC_UP2STREAM_PLATE_AMP: Final[str] = "Up2Stream Plate Amp"
 MODELS_IEAST_AUDIOCAST_M5: Final[str] = "AudioCast M5"
 MODELS_WIIM_AMP: Final[str] = "WiiM Amp"
@@ -49,9 +51,10 @@
     "UP2STREAM_AMP_V3": (MANUFACTURER_ARYLIC, MODELS_ARYLIC_UP2STREAM_AMP_V3),
     "UP2STREAM_AMP_V4": (MANUFACTURER_ARYLIC, MODELS_ARYLIC_UP2STREAM_AMP_V4),
     "UP2STREAM_PRO_V3": (MANUFACTURER_ARYLIC, MODELS_ARYLIC_UP2STREAM_PRO_V3),
+    "S10P_WIFI": (MANUFACTURER_ARYLIC, MODELS_ARYLIC_S10P),
     "ARYLIC_V20": (MANUFACTURER_ARYLIC, MODELS_ARYLIC_UP2STREAM_PLATE_AMP),
     "UP2STREAM_MINI_V3": (MANUFACTURER_ARYLIC, MODELS_GENERIC),
-    "UP2STREAM_AMP_2P1": (MANUFACTURER_ARYLIC, MODELS_GENERIC),
+    "UP2STREAM_AMP_2P1": (MANUFACTURER_ARYLIC, MODELS_ARYLIC_UP2STREAM_AMP_2P1),
     "RP0014_A50C_S": (MANUFACTURER_ARYLIC, MODELS_GENERIC),
     "ARYLIC_A30": (MANUFACTURER_ARYLIC, MODELS_GENERIC),
     "ARYLIC_SUBWOOFER": (MANUFACTURER_ARYLIC, MODELS_GENERIC),

tests/components/linkplay/test_option_flow.py

@@ -0,0 +1,39 @@
+"""Tests for the LinkPlay option flow."""
+
+
+from tests.common import MockConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.components.linkplay.config_flow import LinkPlayOptionsFlow
+from homeassistant.components.linkplay.const import DOMAIN
+
+import pytest
+
+@pytest.fixture
+def mock_config_entry(hass: HomeAssistant):
+    """Mock a ConfigEntry for LinkPlay Options."""
+    entry = MockConfigEntry(
+        domain=DOMAIN,  
+        title="Test Entry",
+        data={"use_ip_url": True},
+        options={"use_ip_url": False},
+    )
+    entry.add_to_hass(hass)
+    return entry
+
+async def test_options_flow(hass: HomeAssistant, mock_config_entry):
+    """Test the options flow for the LinkPlay component."""
+
+    # Initialize the options flow
+    flow = LinkPlayOptionsFlow()
+
+    # Start the options flow
+    result = await flow.async_step_init()
+
+    assert result["type"] == "form"
+    assert result["step_id"] == "init"
+
+    result = await flow.async_step_update_options(user_input={"use_ip_url": True})
+
+    # Ensure that the new options are processed correctly
+    assert result["type"] == "create_entry"
+    assert mock_config_entry.options == {"use_ip_url": True}