Add a service to cancle a VTO call

Author: rroller

README.md

@@ -195,7 +195,8 @@ Service | Parameters | Description
 `dahua.set_record_mode` | `target`: camera.cam13_main <br /> `mode`: Auto, On, Off | Sets the record mode. On is always on recording. Off is always off. Auto based on motion settings, etc.
 `dahua.enable_all_ivs_rules` | `target`: camera.cam13_main <br /> `channel`: The camera channel, e.g.: 0 <br /> `enabled`: True to enable all IVS rules, False to disable all IVS rules | Enables or disables all IVS rules
 `dahua.enable_ivs_rule` | `target`: camera.cam13_main <br /> `channel`: The camera channel, e.g.: 0 <br /> `index`: The rule index <br /> enabled`: True to enable the IVS rule, False to disable the IVS rule | Enable or disable an IVS rule
-`dahua.vto_open_door` | `target`: camera.cam13_main <br /> `door_id`: The door ID to open, e.g.: 1 <br /> | Opens a door via a VTO
+`dahua.vto_open_door` | `target`: camera.cam13_main <br /> `door_id`: The door ID to open, e.g.: 1 <br /> Opens a door via a VTO
+`dahua.vto_cancel_call` | `target`: camera.cam13_main <br />Cancels a call on a VTO device (Doorbell)
 `dahua.set_video_in_day_night_mode` | `target`: camera.cam13_main <br /> `config_type`: The config type: general, day, night <br /> `mode`: The mode: Auto, Color, BlackWhite. Note Auto is also known as Brightness by Dahua|Set the camera's Day/Night Mode. For example, Color, BlackWhite, or Auto
 
 

custom_components/dahua/__init__.py

@@ -34,6 +34,7 @@
     STARTUP_MESSAGE,
     CONF_CHANNEL,
 )
+from .vto import DahuaVTOClient
 
 SCAN_INTERVAL_SECONDS = timedelta(seconds=30)
 
@@ -605,6 +606,13 @@ def supports_smart_motion_detection(self) -> bool:
         """ True if smart motion detection is supported"""
         return self._supports_smart_motion_detection
 
+    def get_vto_client(self) -> DahuaVTOClient:
+        """
+        Returns an instance of the connected VTO client if this is a VTO device. We need this because there's different
+        ways to call a VTO device and the VTO client will handle that. For example, to hang up a call
+        """
+        return self.dahua_vto_event_thread.vto_client
+
 
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Handle removal of an entry."""

custom_components/dahua/button.py

@@ -0,0 +1,12 @@
+"""
+Button entity platform for Dahua.
+https://developers.home-assistant.io/docs/core/entity/button
+Buttons require HomeAssistant 2021.12 or greater
+"""
+from homeassistant.core import HomeAssistant
+
+
+async def async_setup_entry(hass: HomeAssistant, entry, async_add_devices):
+    """Setup the button platform."""
+    # TODO: Add some buttons. This requires a pretty recent version of HomeAssistant so I'm waiting a bit longer
+    # before adding buttons

custom_components/dahua/camera.py

@@ -32,6 +32,7 @@
 SERVICE_ENABLE_ALL_IVS_RULES = "enable_all_ivs_rules"
 SERVICE_ENABLE_IVS_RULE = "enable_ivs_rule"
 SERVICE_VTO_OPEN_DOOR = "vto_open_door"
+SERVICE_VTO_CANCEL_CALL = "vto_cancel_call"
 SERVICE_SET_DAY_NIGHT_MODE = "set_video_in_day_night_mode"
 
 
@@ -130,6 +131,12 @@ async def async_setup_entry(hass: HomeAssistant, config_entry, async_add_entitie
         "async_vto_open_door"
     )
 
+    platform.async_register_entity_service(
+        SERVICE_VTO_CANCEL_CALL,
+        {},
+        "async_vto_cancel_call"
+    )
+
     platform.async_register_entity_service(
         SERVICE_SET_CHANNEL_TITLE,
         {
@@ -317,6 +324,10 @@ async def async_vto_open_door(self, door_id: int):
         """ Handles the service call from SERVICE_VTO_OPEN_DOOR """
         await self._coordinator.client.async_access_control_open_door(door_id)
 
+    async def async_vto_cancel_call(self):
+        """ Handles the service call from SERVICE_VTO_CANCEL_CALL to cancel VTO calls """
+        await self._coordinator.get_vto_client().cancel_call()
+
     async def async_set_service_set_channel_title(self, text1: str, text2: str):
         """ Handles the service call from SERVICE_SET_CHANNEL_TITLE to set profile mode to day/night """
         channel = self._coordinator.get_channel()

custom_components/dahua/services.yaml

@@ -369,3 +369,12 @@ vto_open_door:
           mode: box
           min: 0
           max: 100
+
+vto_cancel_call:
+  name: Cancel VTO call
+  description: Cancels a VTO call
+  target:
+    entity:
+      integration: dahua
+      domain: camera
+

custom_components/dahua/thread.py

@@ -86,6 +86,7 @@ def __init__(self, hass: HomeAssistant, client: DahuaClient, on_receive_vto_even
         self._username = username
         self._password = password
         self._is_ssl = False
+        self.vto_client = None
 
     def run(self):
         """Fetch VTO events"""
@@ -104,9 +105,19 @@ def run(self):
                 # how well do we know when we are shutting down HA?
                 loop = asyncio.new_event_loop()
 
-                client = loop.create_connection(
-                    lambda: DahuaVTOClient(self._host, self._username, self._password, self._is_ssl,
-                                           self.on_receive_vto_event), host=self._host, port=self._port)
+                def vto_client_lambda():
+                    # Notice how we set vto_client client here. This is so nasty, I'm embarrassed to put this into the
+                    # code, but I'm not a python expert and it works well enough and this is just a spare time project
+                    # so here it is. We need to capture an instance of the DahuaVTOClient so we can use it later on
+                    # in switches to execute commands on the VTO. We need the client connected to the event loop
+                    # which is done through loop.create_connection. This makes it awkward to capture... which is why
+                    # I've done this. I'm sure there's a better way :)
+                    self.vto_client = DahuaVTOClient(self._host, self._username, self._password, self._is_ssl,
+                                                     self.on_receive_vto_event)
+                    return self.vto_client
+
+                client = loop.create_connection(vto_client_lambda, host=self._host, port=self._port)
+
                 loop.run_until_complete(client)
                 loop.run_forever()
                 loop.close()

custom_components/dahua/vto.py

@@ -37,8 +37,6 @@
     DAHUA_SERIAL_NUMBER
 ]
 
-ENDPOINT_ACCESS_CONTROL = "accessControl.cgi?action=openDoor&UserID=101&Type=Remote&channel="
-
 
 class DahuaVTOClient(asyncio.Protocol):
     requestId: int
@@ -76,11 +74,10 @@ def __init__(self, host: str, username: str, password: str, is_ssl: bool, on_rec
 
         # This is the hook back into HA
         self.on_receive_vto_event = on_receive_vto_event
-
         self._loop = asyncio.get_event_loop()
 
     def connection_made(self, transport):
-        _LOGGER.debug("Connection established")
+        _LOGGER.debug("VTO connection established")
 
         try:
             self.transport = transport
@@ -266,6 +263,15 @@ def handle_access_control(message):
 
         self.send(DAHUA_CONFIG_MANAGER_GETCONFIG, handle_access_control, request_data)
 
+    async def cancel_call(self):
+        _LOGGER.info("Cancelling call on VTO")
+
+        def cancel(message):
+            _LOGGER.info(f"Got cancel call response: {message}")
+
+        self.send("console.runCmd", cancel, {"command": "hc"})
+        return True
+
     def load_version(self):
         _LOGGER.info("Get version")
 
@@ -326,52 +332,6 @@ def handle_keep_alive(message):
 
         self.send(DAHUA_GLOBAL_KEEPALIVE, handle_keep_alive, request_data)
 
-    def access_control_open_door(self, door_id: int = 1):
-        is_locked = self.lock_status.get(door_id, False)
-        should_unlock = False
-
-        try:
-            if is_locked:
-                _LOGGER.info(f"Access Control - Door #{door_id} is already unlocked, ignoring request")
-
-            else:
-                is_locked = True
-                should_unlock = True
-
-                self.lock_status[door_id] = is_locked
-                self.publish_lock_state(door_id, False)
-
-                url = f"{self.base_url}{ENDPOINT_ACCESS_CONTROL}{door_id}"
-
-                response = requests.get(url, verify=False, auth=self.auth)
-
-                response.raise_for_status()
-
-        except Exception as ex:
-            exc_type, exc_obj, exc_tb = sys.exc_info()
-
-            _LOGGER.error(f"Failed to open door, error: {ex}, Line: {exc_tb.tb_lineno}")
-
-        if should_unlock and is_locked:
-            Timer(float(self.hold_time), self.magnetic_unlock, (self, door_id)).start()
-
-    @staticmethod
-    def magnetic_unlock(self, door_id):
-        self.lock_status[door_id] = False
-        self.publish_lock_state(door_id, True)
-
-    def publish_lock_state(self, door_id: int, is_locked: bool):
-        state = "Locked" if is_locked else "Unlocked"
-
-        _LOGGER.info(f"Access Control - {state} magnetic lock #{door_id}")
-
-        message = {
-            "door": door_id,
-            "isLocked": is_locked
-        }
-
-        _LOGGER.info("locked %s", json.dumps(message, indent=4))
-
     @staticmethod
     def parse_response(response):
         result = []