infoscreen.py

#!/usr/bin/env python3

import json
import time
import sys
import re
from threading import Lock
import paho.mqtt.client as mqtt


class Infoscreen:

    mqtt_host = "autoc4"
    mqtt_port = 1883
    mqtt_keepalive = 60

    def __init__(self, clientid, stdscr):

        # self.is_on = { 'tuer' : False }
        self.blank = False
        self.stdscr = stdscr
        self.lock = Lock()

        self.registered_windows = list()

        self._init_windows()
        self._init_mqtt(clientid)

    def _init_mqtt(self, clientid):

        self.heartbeat_topic = "heartbeat/" + clientid

        self.mqttc = mqtt.Client(clientid)
        self.mqttc.on_message = self.on_message
        self.mqttc.on_connect = self.on_connect
        self.mqttc.will_set(self.heartbeat_topic, bytearray(b"\x00"), 2, True)

        self.mqttc.connect(self.mqtt_host, self.mqtt_port, self.mqtt_keepalive)

        self.mqttc.loop_start()

    def _init_windows(self):

        raise NotImplementedError("Abstract method")

    def on_connect(self, a, b, c, rc):

        if rc != 0:
            sys.exit(1)  # connect failed # TODO

        else:

            self.mqttc.subscribe(
                [
                    listener["subscribe"]
                    for registration in self.registered_windows
                    for listener in registration["listeners"]
                ]
            )

            self.mqttc.publish(self.heartbeat_topic, bytearray(b"\x01"), 2, retain=True)

    def add_window(self, window, listeners):
        self.registered_windows.append(
            {
                "window": window,
                "listeners": [
                    {
                        "custom": listener["custom"] if "custom" in listener else False,
                        "subscribe": (
                            listener["subscribe"] if "subscribe" in listener else None
                        ),
                        "json": listener["json"] if "json" in listener else True,
                        "utf8": listener["utf8"] if "utf8" in listener else True,
                        "callback": listener["callback"],
                    }
                    for listener in listeners
                ],
            }
        )

    def on_message(self, client, userdata, message):

        self.lock.acquire()

        try:
            for registration in self.registered_windows:
                for listener in registration["listeners"]:
                    if mqtt.topic_matches_sub(listener["subscribe"][0], message.topic):
                        if listener["custom"]:
                            listener["callback"](message)
                        else:
                            payload = message.payload
                            if listener["json"]:
                                try:
                                    payload = json.loads(
                                        message.payload.decode("utf-8")
                                    )
                                except Exception as msg:
                                    print(
                                        'An error occured while parsing JSON for topic "%s" : %s'
                                        % (message.topic, str(msg))
                                    )
                            elif listener["utf8"]:
                                payload = message.payload.decode("utf-8")
                            listener["callback"](payload)
        except Exception as msg:
            print(msg)

        self.lock.release()

        # elif (message.topic == "licht/wohnzimmer/tuer"):
        #     self.is_on['tuer'] = (message.payload[0] != 0)

    def run(self):

        while True:

            self.lock.acquire()

            self.stdscr.clear()
            for registration in self.registered_windows:
                if registration["window"] is not None:
                    registration["window"].show()

            self.lock.release()

            time.sleep(0.1)


#        if (not isOn['tuer'] and not blank):
#            blank = True
#            os.system("setterm --blank force --powersave on")
#            #os.system("setterm --powersave powerdown")
#        elif ((isOn['tuer']) and blank):
#            blank = False
#            os.system("setterm --blank poke")
#            os.system("setterm --blank 0")