Python - Entwurfsmuster mit "Listener"

[Micki (Gast)]

Hallo zusammen,

Folgende Anfängerfrage zum Entwurfsmuster (Ist lange her, dass ich das 
letzte Mal objektorientiert unterwegs war...):

In meiner main() erzeuge ich eine Instanz eines MQTT-Clients:

def main():
    client = mqtt.Client()
    client.on_connect = on_connect
    # ...

if __name__ == "__main__":
    main()

die "Callback"-Funktionen sind ebenfalls definiert, z.B.:

def on_connect(client, userdata, flags, rc):
    print("Connected")
    # do something

def on_data(client, userdata, flags, rc):
    # do something

Soweit, so gut. Nun möchte ich mir in der main() eine Instanz meiner 
Klasse "Player" erzeugen. Diese hat u.a. die Funktion 
"load_content(self, number)", mit der verschiedene Inhalte umgeschaltet 
werden können.

Beides für sich funktioniert einwandfrei, welche Entwurdsmuster bieten 
sich nun an, auf MQTT-Input hin den Player umzuschalten?

Mir fällt sowas ein wie:

- Ich erstelle eine eigene Klasse MQTTClient, die dann das "client = 
mqtt.Client()" als Klassenvariable bekommt (also statt das in main() zu 
machen)
- MQTTClient erhält eine Variable listener + eine SetterFunktion.

Dann geht also in der main() sowas wie

client = MQTTClient()
player = Player()

client.setListener(player)

und die Callbackfunktion kann dann entsprechend sowas wie

def on_data(client, userdata, flags, rc):
    print("Data received")
    client.listener.dataReceived(userdata)

Klasse "Player" muss dieses "Interface" natürlich implementieren. 
Alternativ, aber aus Sicht des MQTT-Clients gesehen etwas weniger 
"universell" ginge evtl. auch direkt

def on_data(client, userdata, flags, rc):
    print("Data received")
    client.listener.load_content(client, number)

Ist das so sinnvoll, oder welche anderen Möglichkeiten habe ich? Ist 
dieses "Listener-Pattern" generell üblich?

[imonbln (Gast)]

Ich denke, du solltest den MQTT Bus in einer eigenen Klasse Kapseln.

Diese Klasse bekommt dann ein Player-objekt als Komposition und wirkt 
wie ein Adapter, um die MQTT Messages in sinnvolle Aktionen umzusetzen. 
Wenn du es noch generischer haben willst, implementierst du ein Bridge 
Pattern, was dann noch unterschiedliche Arten von Playern behandeln 
kann, aber vermutlich ist das im Augenblick Overkill. Das hat den 
Vorteil das er Player nicht wissen muss das er über MQTT gesteuert wird 
und nicht angepasst werden muss.

ungefähr so:

class MqttPollBus:

    def __init__(self, mqttname: str, player: Player):
        self.player = player
        self.name = mqttname

        self.mqtt_client = mqtt.Client(client_id=self.name,
               clean_session=True)
        # register callbacks
        self.mqtt_client.on_message = self.mqtt_message
        [...]

   def mqtt_message(self, client, userdata, message):
      # get message information and convert
      self.player.method(<input from MQTT>)