Dynamic modulation + cleanup

homeassistant/components/esphome/entry_data.py

@@ -29,6 +29,7 @@ from aioesphomeapi import (
     Event,
     EventInfo,
     FanInfo,
+    InfraredInfo,
     LightInfo,
     LockInfo,
     MediaPlayerInfo,
@@ -85,6 +86,7 @@ INFO_TYPE_TO_PLATFORM: dict[type[EntityInfo], Platform] = {
     DateTimeInfo: Platform.DATETIME,
     EventInfo: Platform.EVENT,
     FanInfo: Platform.FAN,
+    InfraredInfo: Platform.INFRARED,
     LightInfo: Platform.LIGHT,
     LockInfo: Platform.LOCK,
     MediaPlayerInfo: Platform.MEDIA_PLAYER,
@@ -520,6 +522,27 @@ class RuntimeEntryData:
             ),
         )
 
+    @callback
+    def async_on_infrared_proxy_receive(
+        self, hass: HomeAssistant, receive_event: Any
+    ) -> None:
+        """Handle an infrared proxy receive event."""
+        # Fire a Home Assistant event with the infrared data
+        device_info = self.device_info
+        if not device_info:
+            return
+
+        hass.bus.async_fire(
+            f"{DOMAIN}_infrared_proxy_received",
+            {
+                "device_name": device_info.name,
+                "device_mac": device_info.mac_address,
+                "entry_id": self.entry_id,
+                "key": receive_event.key,
+                "timings": receive_event.timings,
+            },
+        )
+
     @callback
     def async_register_assist_satellite_config_updated_callback(
         self,

homeassistant/components/esphome/infrared.py

@@ -0,0 +1,100 @@
+"""Infrared platform for ESPHome."""
+
+from __future__ import annotations
+
+import logging
+
+from aioesphomeapi import EntityInfo, EntityState, InfraredCapability, InfraredInfo
+
+from homeassistant.components.infrared import InfraredCommand, InfraredEntity
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import entity_platform
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .const import DOMAIN
+from .entity import EsphomeEntity, async_static_info_updated
+from .entry_data import ESPHomeConfigEntry
+
+_LOGGER = logging.getLogger(__name__)
+
+PARALLEL_UPDATES = 0
+
+
+class EsphomeInfraredEntity(EsphomeEntity[InfraredInfo, EntityState], InfraredEntity):
+    """ESPHome infrared entity using native API."""
+
+    _attr_has_entity_name = True
+    _attr_name = "Infrared Transmitter"
+
+    @callback
+    def _on_device_update(self) -> None:
+        """Call when device updates or entry data changes."""
+        super()._on_device_update()
+        if self._entry_data.available:
+            # Infrared entities should go available as soon as the device comes online
+            self.async_write_ha_state()
+
+    async def async_send_command(self, command: InfraredCommand) -> None:
+        """Send an IR command.
+
+        Raises:
+            HomeAssistantError: If transmission fails.
+        """
+        timings = [
+            interval
+            for timing in command.get_raw_timings()
+            for interval in (timing.high_us, -timing.low_us)
+        ]
+        _LOGGER.debug("Sending command: %s", timings)
+
+        try:
+            self._client.infrared_rf_transmit_raw_timings(
+                self._static_info.key,
+                carrier_frequency=command.modulation,
+                timings=timings,
+            )
+        except Exception as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="error_sending_ir_command",
+                translation_placeholders={
+                    "device_name": self._device_info.name,
+                    "error": str(err),
+                },
+            ) from err
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: ESPHomeConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up ESPHome infrared entities, filtering out receiver-only devices."""
+    entry_data = entry.runtime_data
+    entry_data.info[InfraredInfo] = {}
+    platform = entity_platform.async_get_current_platform()
+
+    def filtered_static_info_update(infos: list[EntityInfo]) -> None:
+        transmitter_infos: list[EntityInfo] = [
+            info
+            for info in infos
+            if isinstance(info, InfraredInfo)
+            and info.capabilities & InfraredCapability.TRANSMITTER
+        ]
+        async_static_info_updated(
+            hass,
+            entry_data,
+            platform,
+            async_add_entities,
+            InfraredInfo,
+            EsphomeInfraredEntity,
+            EntityState,
+            transmitter_infos,
+        )
+
+    entry_data.cleanup_callbacks.append(
+        entry_data.async_register_static_info_callback(
+            InfraredInfo, filtered_static_info_update
+        )
+    )

homeassistant/components/esphome/manager.py

@@ -17,6 +17,8 @@ from aioesphomeapi import (
     EncryptionPlaintextAPIError,
     ExecuteServiceResponse,
     HomeassistantServiceCall,
+    InfraredCapability,
+    InfraredInfo,
     InvalidAuthAPIError,
     InvalidEncryptionKeyAPIError,
     LogLevel,
@@ -692,6 +694,15 @@ class ESPHomeManager:
                 cli.subscribe_zwave_proxy_request(self._async_zwave_proxy_request)
             )
 
+        if any(
+            isinstance(info, InfraredInfo)
+            and info.capabilities & InfraredCapability.RECEIVER
+            for info in entity_infos
+        ):
+            entry_data.disconnect_callbacks.add(
+                cli.subscribe_infrared_rf_receive(self._async_infrared_proxy_receive)
+            )
+
         cli.subscribe_home_assistant_states_and_services(
             on_state=entry_data.async_update_state,
             on_service_call=self.async_on_service_call,
@@ -722,6 +733,10 @@ class ESPHomeManager:
             self.hass, self.entry_data.device_info, zwave_home_id
         )
 
+    def _async_infrared_proxy_receive(self, receive_event: Any) -> None:
+        """Handle an infrared proxy receive event."""
+        self.entry_data.async_on_infrared_proxy_receive(self.hass, receive_event)
+
     async def on_disconnect(self, expected_disconnect: bool) -> None:
         """Run disconnect callbacks on API disconnect."""
         entry_data = self.entry_data

homeassistant/components/esphome/strings.json

@@ -137,6 +137,9 @@
     "error_compiling": {
       "message": "Error compiling {configuration}. Try again in ESPHome dashboard for more information."
     },
+    "error_sending_ir_command": {
+      "message": "Error sending IR command to {device_name}: {error}"
+    },
     "error_uploading": {
       "message": "Error during OTA (Over-The-Air) update of {configuration}. Try again in ESPHome dashboard for more information."
     },

tests/components/esphome/test_infrared.py

@@ -0,0 +1,166 @@
+"""Test ESPHome infrared platform."""
+
+from aioesphomeapi import APIClient, InfraredCapability, InfraredInfo
+import pytest
+
+from homeassistant.components import infrared
+from homeassistant.const import STATE_UNAVAILABLE
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+
+from .conftest import MockESPHomeDeviceType
+
+ENTITY_ID = "infrared.test_ir"
+
+
+async def _mock_ir_device(
+    mock_esphome_device: MockESPHomeDeviceType,
+    mock_client: APIClient,
+    capabilities: InfraredCapability = InfraredCapability.TRANSMITTER,
+) -> MockESPHomeDeviceType:
+    entity_info = [
+        InfraredInfo(object_id="ir", key=1, name="IR", capabilities=capabilities)
+    ]
+    return await mock_esphome_device(
+        mock_client=mock_client, entity_info=entity_info, states=[]
+    )
+
+
+@pytest.mark.parametrize(
+    ("capabilities", "entity_created"),
+    [
+        (InfraredCapability.TRANSMITTER, True),
+        (InfraredCapability.RECEIVER, False),
+        (InfraredCapability.TRANSMITTER | InfraredCapability.RECEIVER, True),
+        (0, False),
+    ],
+)
+async def test_infrared_entity_transmitter(
+    hass: HomeAssistant,
+    mock_client: APIClient,
+    mock_esphome_device: MockESPHomeDeviceType,
+    capabilities: InfraredCapability,
+    entity_created: bool,
+) -> None:
+    """Test infrared entity with transmitter capability is created."""
+    await _mock_ir_device(mock_esphome_device, mock_client, capabilities)
+
+    state = hass.states.get(ENTITY_ID)
+    assert (state is not None) == entity_created
+
+    emitters = infrared.async_get_emitters(hass)
+    assert (len(emitters) == 1) == entity_created
+
+
+async def test_infrared_multiple_entities_mixed_capabilities(
+    hass: HomeAssistant,
+    mock_client: APIClient,
+    mock_esphome_device: MockESPHomeDeviceType,
+) -> None:
+    """Test multiple infrared entities with mixed capabilities."""
+    entity_info = [
+        InfraredInfo(
+            object_id="ir_transmitter",
+            key=1,
+            name="IR Transmitter",
+            capabilities=InfraredCapability.TRANSMITTER,
+        ),
+        InfraredInfo(
+            object_id="ir_receiver",
+            key=2,
+            name="IR Receiver",
+            capabilities=InfraredCapability.RECEIVER,
+        ),
+        InfraredInfo(
+            object_id="ir_transceiver",
+            key=3,
+            name="IR Transceiver",
+            capabilities=InfraredCapability.TRANSMITTER | InfraredCapability.RECEIVER,
+        ),
+    ]
+    await mock_esphome_device(
+        mock_client=mock_client,
+        entity_info=entity_info,
+        states=[],
+    )
+
+    # Only transmitter and transceiver should be created
+    assert hass.states.get("infrared.test_ir_transmitter") is not None
+    assert hass.states.get("infrared.test_ir_receiver") is None
+    assert hass.states.get("infrared.test_ir_transceiver") is not None
+
+    emitters = infrared.async_get_emitters(hass)
+    assert len(emitters) == 2
+
+
+async def test_infrared_send_command_success(
+    hass: HomeAssistant,
+    mock_client: APIClient,
+    mock_esphome_device: MockESPHomeDeviceType,
+) -> None:
+    """Test sending IR command successfully."""
+    await _mock_ir_device(mock_esphome_device, mock_client)
+
+    command = infrared.NECInfraredCommand(address=0x04, command=0x08, modulation=38000)
+    await infrared.async_send_command(hass, ENTITY_ID, command)
+
+    # Verify the command was sent to the ESPHome client
+    mock_client.infrared_rf_transmit_raw_timings.assert_called_once()
+    call_args = mock_client.infrared_rf_transmit_raw_timings.call_args
+    assert call_args[0][0] == 1  # key
+    assert call_args[1]["carrier_frequency"] == 38000
+
+    # Verify timings (alternating positive/negative values)
+    timings = call_args[1]["timings"]
+    assert len(timings) > 0
+    for i in range(0, len(timings), 2):
+        assert timings[i] >= 0
+    for i in range(1, len(timings), 2):
+        assert timings[i] <= 0
+
+
+async def test_infrared_send_command_failure(
+    hass: HomeAssistant,
+    mock_client: APIClient,
+    mock_esphome_device: MockESPHomeDeviceType,
+) -> None:
+    """Test sending IR command with failure raises HomeAssistantError."""
+    await _mock_ir_device(mock_esphome_device, mock_client)
+
+    mock_client.infrared_rf_transmit_raw_timings.side_effect = Exception(
+        "Connection lost"
+    )
+
+    command = infrared.NECInfraredCommand(address=0x04, command=0x08, modulation=38000)
+
+    with pytest.raises(HomeAssistantError) as exc_info:
+        await infrared.async_send_command(hass, ENTITY_ID, command)
+    assert exc_info.value.translation_domain == "esphome"
+    assert exc_info.value.translation_key == "error_sending_ir_command"
+
+
+async def test_infrared_entity_availability(
+    hass: HomeAssistant,
+    mock_client: APIClient,
+    mock_esphome_device: MockESPHomeDeviceType,
+) -> None:
+    """Test infrared entity becomes available after device reconnects."""
+    mock_device = await _mock_ir_device(mock_esphome_device, mock_client)
+
+    state = hass.states.get(ENTITY_ID)
+    assert state is not None
+    assert state.state != STATE_UNAVAILABLE
+
+    await mock_device.mock_disconnect(False)
+    await hass.async_block_till_done()
+
+    state = hass.states.get(ENTITY_ID)
+    assert state is not None
+    assert state.state == STATE_UNAVAILABLE
+
+    await mock_device.mock_connect()
+    await hass.async_block_till_done()
+
+    state = hass.states.get(ENTITY_ID)
+    assert state is not None
+    assert state.state != STATE_UNAVAILABLE