Axis IO-port support (#23312)

Support digital inputs and supervised inputs, digital outputs and relays

homeassistant/components/axis/binary_sensor.py

@@ -2,6 +2,8 @@
 
 from datetime import timedelta
 
+from axis.event_stream import CLASS_INPUT, CLASS_OUTPUT
+
 from homeassistant.components.binary_sensor import BinarySensorDevice
 from homeassistant.const import CONF_MAC, CONF_TRIGGER_TIME
 from homeassistant.core import callback
@@ -9,7 +11,8 @@ from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.event import async_track_point_in_utc_time
 from homeassistant.util.dt import utcnow
 
-from .const import DOMAIN as AXIS_DOMAIN, LOGGER
+from .axis_base import AxisEventBase
+from .const import DOMAIN as AXIS_DOMAIN
 
 
 async def async_setup_entry(hass, config_entry, async_add_entities):
@@ -21,32 +24,21 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
     def async_add_sensor(event_id):
         """Add binary sensor from Axis device."""
         event = device.api.event.events[event_id]
-        async_add_entities([AxisBinarySensor(event, device)], True)
+
+        if event.CLASS != CLASS_OUTPUT:
+            async_add_entities([AxisBinarySensor(event, device)], True)
 
     device.listeners.append(async_dispatcher_connect(
         hass, device.event_new_sensor, async_add_sensor))
 
 
-class AxisBinarySensor(BinarySensorDevice):
+class AxisBinarySensor(AxisEventBase, BinarySensorDevice):
     """Representation of a binary Axis event."""
 
     def __init__(self, event, device):
         """Initialize the Axis binary sensor."""
-        self.event = event
-        self.device = device
+        super().__init__(event, device)
         self.remove_timer = None
-        self.unsub_dispatcher = None
-
-    async def async_added_to_hass(self):
-        """Subscribe sensors events."""
-        self.event.register_callback(self.update_callback)
-        self.unsub_dispatcher = async_dispatcher_connect(
-            self.hass, self.device.event_reachable, self.update_callback)
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Disconnect device object when removed."""
-        self.event.remove_callback(self.update_callback)
-        self.unsub_dispatcher()
 
     @callback
     def update_callback(self, no_delay=False):
@@ -67,7 +59,6 @@ class AxisBinarySensor(BinarySensorDevice):
         @callback
         def _delay_update(now):
             """Timer callback for sensor update."""
-            LOGGER.debug("%s called delayed (%s sec) update", self.name, delay)
             self.async_schedule_update_ha_state()
             self.remove_timer = None
 
@@ -83,32 +74,10 @@ class AxisBinarySensor(BinarySensorDevice):
     @property
     def name(self):
         """Return the name of the event."""
-        return '{} {} {}'.format(
-            self.device.name, self.event.TYPE, self.event.id)
+        if self.event.CLASS == CLASS_INPUT and self.event.id and \
+                self.device.api.vapix.ports[self.event.id].name:
+            return '{} {}'.format(
+                self.device.name,
+                self.device.api.vapix.ports[self.event.id].name)
 
-    @property
-    def device_class(self):
-        """Return the class of the event."""
-        return self.event.CLASS
-
-    @property
-    def unique_id(self):
-        """Return a unique identifier for this device."""
-        return '{}-{}-{}'.format(
-            self.device.serial, self.event.topic, self.event.id)
-
-    def available(self):
-        """Return True if device is available."""
-        return self.device.available
-
-    @property
-    def should_poll(self):
-        """No polling needed."""
-        return False
-
-    @property
-    def device_info(self):
-        """Return a device description for device registry."""
-        return {
-            'identifiers': {(AXIS_DOMAIN, self.device.serial)}
-        }
+        return super().name