Still iterating on the home cinema configuration

apps/vertex2.py

@@ -6,6 +6,7 @@ import ad_toolbox.smartcondition as SmartCondition
 import time
 import socket
 import threading
+import re
 from urllib.parse import urlparse
 
 class Vertex2(SmartObject):
@@ -16,9 +17,25 @@ class Vertex2(SmartObject):
         self._tx0_recovery_restore_handle = None
 
         self.video_tx_signal_sensor = self.create_entity(
-                self.args['video_tx_signal_sensor'], 
+            self.args['video_tx_signal_sensor'],
+            state='unavailable',
+        )
+        self.video_tx_signal_sensors = {
+            index: self.create_entity(
+                self.generate_output_sensor_name(self.args['video_tx_signal_sensor'], index),
                 state='unavailable',
             )
+            for index in range(2)
+        }
+        self.allm_sensor = self.create_entity(self.args['allm_sensor'], state='unavailable')
+        self.allm_sensors = {
+            index: self.create_entity(
+                self.generate_output_sensor_name(self.args['allm_sensor'], index),
+                state='unavailable',
+            )
+            for index in range(2)
+        }
+        self._tx_video_signal_values = {0: 'unavailable', 1: 'unavailable'}
 
         self.audio_out_signal_sensor = self.create_entity(
                         self.args['audio_out_signal_sensor'], 
@@ -61,6 +78,13 @@ class Vertex2(SmartObject):
             if "input_config" in self.args:
                 self.listen_state(self.on_input_selected_sensor_change,sensor_name)
 
+        default_input_config = self.get_input_config(None)
+        self.input_selected_sensor = self.create_entity(
+            self.args['input_selected_sensor'],
+            state=default_input_config['name'],
+            icon=default_input_config['icon'],
+        )
+
         self.unreachable_sensor = self.create_entity(
             self.args['unreachable_sensor'],
             state='off',
@@ -187,6 +211,7 @@ class Vertex2(SmartObject):
                                     snapshot = dict(status)
                                     self.run_in(self._apply_vertex2_status, 0,
                                                 rx0=snapshot['rx0'], rx1=snapshot['rx1'],
+                                                tx0=snapshot['tx0'], tx1=snapshot['tx1'],
                                                 audout=snapshot['audout'], insel=snapshot['insel'])
                                     status_started = None
                                     consecutive = (previous_snapshot_generation is not None
@@ -215,6 +240,11 @@ class Vertex2(SmartObject):
                     break
                 self.unreachable_sensor.set_state(state='on')
                 self.video_tx_signal_sensor.set_state(state='unavailable')
+                for sensor in self.video_tx_signal_sensors.values():
+                    sensor.set_state(state='unavailable')
+                self.allm_sensor.set_state(state='unavailable')
+                for sensor in self.allm_sensors.values():
+                    sensor.set_state(state='unavailable')
                 self.audio_out_signal_sensor.set_state(state='unavailable')
                 self.log(f'Vertex2 IP INTERRUPT unavailable: {error}', level='WARNING')
                 self._interrupt_stop.wait(5)
@@ -255,6 +285,9 @@ class Vertex2(SmartObject):
     def generate_input_selected_sensor_name(self,i):
         return f"{self.args['input_selected_sensor']}_tx{i}"
 
+    def generate_output_sensor_name(self, sensor_name, output_index):
+        return f'{sensor_name}_tx{output_index}'
+
     def on_input_selected_sensor_change(self,entity, attribute, old, new, kwargs):
         if old != new:
             self.log(f"input_select switch from {old} to {new}")
@@ -323,6 +356,7 @@ class Vertex2(SmartObject):
             state=output_config["name"],
             attributes={"icon": output_config["icon"]},
         )
+        self._refresh_selected_output_signal()
 
         self.log(f"Selecting TX{output_index} as the active output")
         if output_index == 0:
@@ -340,6 +374,7 @@ class Vertex2(SmartObject):
             state=default_output_config["name"],
             attributes={"icon": default_output_config["icon"]},
         )
+        self._refresh_selected_output_signal()
         self.force_tx0_plus5(False)
         self.force_tx1_plus5(False)
 
@@ -437,13 +472,70 @@ class Vertex2(SmartObject):
 
     def update_vertex2_states(self):
         if self.power_plug_entity is not None and self.get_state(self.power_plug_entity) != 'on':
-            self.run_in(self._apply_vertex2_status, 0, rx0='', rx1='', audout='', insel='0 0')
+            self.run_in(self._apply_vertex2_status, 0,
+                        rx0='', rx1='', tx0='', tx1='', audout='', insel='0 0')
             return
         self._status_requested.set()
 
+    def _refresh_selected_output_signal(self):
+        output_name = self.output_selected_sensor.get_state()
+        output_index = self.output_names.get(output_name)
+        self._refresh_selected_input_sensor(output_index)
+        signal = self._tx_video_signal_values.get(output_index, 'unavailable')
+        if self.video_tx_signal_sensor.get_state() != signal:
+            self.video_tx_signal_sensor.set_state(state=signal)
+
+        allm_state = self.allm_sensors[output_index].get_state() if output_index in self.allm_sensors else 'unavailable'
+        if self.allm_sensor.get_state() != allm_state:
+            self.allm_sensor.set_state(state=allm_state)
+
+    def _refresh_selected_input_sensor(self, output_index=None):
+        if output_index not in (0, 1):
+            config = self.get_input_config(None)
+        else:
+            selected_name = self.input_selected_sensors[
+                self.generate_input_selected_sensor_name(output_index)
+            ].get_state()
+            input_number = self.input_names.get(selected_name)
+            config = self.get_input_config(input_number)
+
+        attributes = {}
+        if config.get('icon') is not None:
+            attributes['icon'] = config['icon']
+        if self.input_selected_sensor.get_state() != config['name']:
+            self.input_selected_sensor.set_state(state=config['name'], attributes=attributes)
+        elif attributes:
+            self.input_selected_sensor.set_state(attributes=attributes)
+
+    def _update_output_video_sensors(self, tx0_signal, tx1_signal):
+        values = {0: tx0_signal.strip() or 'unavailable', 1: tx1_signal.strip() or 'unavailable'}
+        self._tx_video_signal_values = values
+        allm_states = {}
+
+        for output_index, signal in values.items():
+            if self.video_tx_signal_sensors[output_index].get_state() != signal:
+                self.video_tx_signal_sensors[output_index].set_state(state=signal)
+            allm_state = 'unavailable' if signal == 'unavailable' else (
+                'on' if re.search(r'\bALLM\b', signal, re.IGNORECASE) else 'off'
+            )
+            allm_states[output_index] = allm_state
+            if self.allm_sensors[output_index].get_state() != allm_state:
+                self.allm_sensors[output_index].set_state(state=allm_state)
+
+        selected_name = self.output_selected_sensor.get_state()
+        selected_index = self.output_names.get(selected_name)
+        selected_signal = values.get(selected_index, 'unavailable')
+        selected_allm = allm_states.get(selected_index, 'unavailable')
+        signal_changed = self.video_tx_signal_sensor.get_state() != selected_signal
+        if signal_changed:
+            self.video_tx_signal_sensor.set_state(state=selected_signal)
+        if self.allm_sensor.get_state() != selected_allm:
+            self.allm_sensor.set_state(state=selected_allm)
+
     def _apply_vertex2_status(self, kwargs):
         self.log_info(
             f"Vertex2 TCP status: RX0={kwargs['rx0']!r}, RX1={kwargs['rx1']!r}, "
+            f"TX0={kwargs['tx0']!r}, TX1={kwargs['tx1']!r}, "
             f"AUDOUT={kwargs['audout']!r}, insel={kwargs['insel']!r}"
         )
         try:
@@ -469,7 +561,7 @@ class Vertex2(SmartObject):
 
         for i in range(2):
             sensor = self.input_selected_sensors[self.generate_input_selected_sensor_name(i)]
-            input_number = None if input_signal in ('unavailable', 'no signal') else portselect[i]
+            input_number = portselect[i]
             input_config = self.get_input_config(input_number)
             name = input_config['name']
             attributes = {}
@@ -481,8 +573,9 @@ class Vertex2(SmartObject):
             elif attributes:
                 sensor.set_state(attributes=attributes)
 
-        if self.video_tx_signal_sensor.get_state() != input_signal:
-            self.video_tx_signal_sensor.set_state(state=input_signal)
+        selected_output_index = self.output_names.get(self.output_selected_sensor.get_state())
+        self._refresh_selected_input_sensor(selected_output_index)
+        self._update_output_video_sensors(kwargs['rx0'], kwargs['rx1'])
         if self.audio_out_signal_sensor.get_state() != audio_out_signal:
             self.audio_out_signal_sensor.set_state(state=audio_out_signal)
         self.unreachable_sensor.set_state(state='off')