BeoGateway/BeoGateway.indigoPlugin/Contents/Server Plugin/plugin.py

import indigo
import asyncore
import json
import time
import logging
import requests
import threading
import os
from datetime import datetime

import Resources.CONSTANTS as CONST
import Resources.MLCONFIG as MLCONFIG
import Resources.MLGW_CLIENT as MLGW
import Resources.MLCLI_CLIENT as MLCLI
import Resources.BLHIP_CLIENT as BLHIP
import Resources.MLtn_CLIENT as MLtn
import Resources.ASBridge as ASBridge


class Plugin(indigo.PluginBase):

    def __init__(self, pluginId, pluginDisplayName, pluginVersion, pluginPrefs):
        indigo.PluginBase.__init__(self, pluginId, pluginDisplayName, pluginVersion, pluginPrefs)

        # Plugin polling and reporting parameters
        self.pollinterval = 595  # ping sent out at 9:55, response evaluated at 10:00
        self.trackmode = self.pluginPrefs.get("trackMode")
        self.verbose = self.pluginPrefs.get("verboseMode")
        self.notifymode = self.pluginPrefs.get("notifyMode")
        self.debug = self.pluginPrefs.get("debugMode")
        self.triggers = []

        # Plugin audio source control parameters
        self.default_audio_source = self.pluginPrefs.get("defaultAudio")
        self.goto_flag = datetime(1982, 4, 1, 13, 30, 00, 342380)

        # Plugin Apple Music control parameters
        self.itunes_control = self.pluginPrefs.get("iTunesControl")
        self.playlist_default = self.pluginPrefs.get("playlist_default")
        self.playlist_green = self.pluginPrefs.get("playlist_green")
        self.playlist_yellow = self.pluginPrefs.get("playlist_yellow")
        self.itunes_source = self.pluginPrefs.get("iTunesSource")

        # Gateway network address and login parameters
        self.host = str(self.pluginPrefs.get('address')).encode('ascii')
        self.port = [int(self.pluginPrefs.get('mlgw_port')),
                     int(self.pluginPrefs.get('hip_port')),
                     23]  # Telnet port - 23
        self.user = str(self.pluginPrefs.get('userID')).encode('ascii')
        self.pwd = str(self.pluginPrefs.get('password')).encode('ascii')

        # Instantiate an AppleScriptBridge MusicController for N.MUSIC control of apple Music
        self.iTunes = ASBridge.MusicController()

    def triggerStartProcessing(self, trigger):
        self.triggers.append(trigger)

    def getDeviceStateList(self, dev):
        stateList = indigo.PluginBase.getDeviceStateList(self, dev)

        if stateList is not None:
            if dev.deviceTypeId in self.devicesTypeDict and dev.deviceTypeId == u"AVrenderer":
                # Add dynamic states onto stateList for devices of type AV renderer
                try:
                    sources = dev.pluginProps['sources']
                    for source_name in sources:
                        stateList.append(
                            {
                                "Disabled": False,
                                "Key": "source." + source_name,
                                "StateKey": sources[source_name]['source'],
                                "StateLabel": "Source is " + source_name,
                                "TriggerLabel": "Source is " + source_name,
                                "Type": 50
                            }
                        )
                except KeyError:
                    indigo.server.log("Device " + dev.name + " does not have state key 'sources'\n",
                                      level=logging.WARNING)
                    pass
        return stateList

    def deviceStartComm(self, dev):
        dev.stateListOrDisplayStateIdChanged()

    def __del__(self):
        indigo.PluginBase.__del__(self)

    # ########################################################################################
    # ##### Indigo UI menu constructors
    @staticmethod
    def zonelistgenerator(filter="", valuesDict=None, typeId="", targetId=0):
        myarray = [("*", "All"), ("Main", "Main")]
        for room in CONST.rooms:
            if (room['Zone'], room['Zone']) not in myarray:
                myarray.append((room['Zone'], room['Zone']))
        return myarray

    @staticmethod
    def roomlistgenerator(filter="", valuesDict=None, typeId="", targetId=0):
        myarray = [("99", "Any")]
        for room in CONST.rooms:
            myarray.append((room['Room_Number'], room['Room_Name']))
        return myarray

    @staticmethod
    def roomlistgenerator2(filter="", valuesDict=None, typeId="", targetId=0):
        myarray = [("*", "All"), ("global", "global")]
        for room in CONST.rooms:
            myarray.append((room['Room_Name'], room['Room_Name']))
        return myarray

    @staticmethod
    def keylistgenerator(filter="", valuesDict=None, typeId="", targetId=0):
        myarray = []
        for item in CONST.beo4_commanddict.items():
            myarray.append(item)
        return myarray

    @staticmethod
    def keylistgenerator2(filter="", valuesDict=None, typeId="", targetId=0):
        myarray = []
        for item in CONST.beoremoteone_keydict.items():
            myarray.append(item)
        return myarray

    @staticmethod
    def beo4sourcelistgenerator(filter="", valuesDict=None, typeId="", targetId=0):
        myarray = []
        for item in CONST.beo4_srcdict.items():
            myarray.append(item)
        return myarray

    @staticmethod
    def beo4sourcelistgenerator2(filter="", valuesDict=None, typeId="", targetId=0):
        myarray = [('Any Source', 'Any Source'), ('Any Audio', 'Any Audio'), ('Any Video', 'Any Video')]
        for item in CONST.beo4_srcdict.items():
            myarray.append(item)
        return myarray

    @staticmethod
    def br1sourcelistgenerator(filter="", valuesDict=None, typeId="", targetId=0):
        myarray = []
        for item in CONST.available_sources:
            myarray.append(item)
        return myarray

    @staticmethod
    def destinationlistgenerator(filter="", valuesDict=None, typeId="", targetId=0):
        myarray = []
        for item in CONST.destselectordict.items():
            myarray.append(item)
        return myarray

    @staticmethod
    def srcactivitylistgenerator(filter="", valuesDict=None, typeId="", targetId=0):
        myarray = [(0x00, "Unknown")]
        for item in CONST.sourceactivitydict.items():
            if item not in myarray:
                myarray.append(item)
        return myarray

    @staticmethod
    def hiptypelistgenerator(filter="", valuesDict=None, typeId="", targetId=0):
        myarray = []
        for item in CONST.blgw_devtypes.items():
            myarray.append(item)
        return myarray

    def playlistgenerator(self, filter="", valuesDict=None, typeId="", targetId=0):
        return self.iTunes.get_playlist_names()

    # ########################################################################################
    # ##### Indigo UI Prefs
    def set_login(self, ui):
        # If LogIn data is updated in config, update the values in the plugin
        self.user = str(ui.get('userID')).encode('ascii')
        self.pwd = str(ui.get('password')).encode('ascii')
        indigo.server.log("BeoGateway device login details updated!", level=logging.DEBUG)

    def set_gateway(self, ui):
        # If gateway network address data is updated in config, update the values in the plugin
        self.host = str(ui.get('address')).encode('ascii')
        self.port = [int(ui.get('mlgw_port')),
                     int(ui.get('hip_port')),
                     23]  # Telnet port - 23
        indigo.server.log("BeoGateway device network address details updated!", level=logging.DEBUG)

    def set_trackmode(self, ui):
        # If Track Mode setting is updated in config, update the value in the plugin
        self.trackmode = ui.get("trackMode")
        indigo.server.log("Track reporting set to " + str(self.trackmode), level=logging.DEBUG)

    def set_verbose(self, ui):
        # If Verbose Mode setting is updated in config, update the value in the plugin
        self.verbose = ui.get("verboseMode")
        indigo.server.log("Verbose Mode set to " + str(self.verbose), level=logging.DEBUG)

    def set_notifymode(self, ui):
        # If Notify Mode setting is updated in config, update the value in the plugin
        self.notifymode = ui.get("notifyMode")
        indigo.server.log("Verbose Mode set to " + str(self.notifymode), level=logging.DEBUG)

    def set_debug(self, ui):
        # If Debug Mode setting is updated in config, update the value in the plugin
        self.debug = ui.get("debugMode")

        # Set the debug flag for the clients
        self.mlcli.debug = self.debug
        self.mlgw.debug = self.debug
        if self.mlcli.isBLGW:
            self.blgw.debug = self.debug
        else:
            self.mltn.debug = self.debug

        # Report the debug flag change
        indigo.server.log("Debug Mode set to " + str(self.debug), level=logging.DEBUG)

    def set_music_control(self, ui):
        # If Apple Music Control setting is updated in config, update the value in the plugin
        self.itunes_control = ui.get("iTunesControl")
        self.itunes_source = ui.get("iTunesSource")

        if self.itunes_control:
            indigo.server.log("Apple Music Control enabled on source: " + str(self.itunes_source), level=logging.DEBUG)
        else:
            indigo.server.log("Apple Music Control set to " + str(self.itunes_control), level=logging.DEBUG)

    def set_default_audio(self, ui):
        # Define default audio source for AVrenderers
        self.default_audio_source = ui.get("defaultAudio")
        indigo.server.log("Default Audio Source set to " + str(self.default_audio_source), level=logging.DEBUG)

    def set_playlist_default(self, ui):
        self.playlist_default = ui.get("playlist_default")
        indigo.server.log("Default Apple Music Playlist set to " + str(self.playlist_default), level=logging.DEBUG)

    def set_playlist_green(self, ui):
        self.playlist_green = ui.get("playlist_green")
        indigo.server.log("Green Key Apple Music Playlist set to " + str(self.playlist_green), level=logging.DEBUG)

    def set_playlist_yellow(self, ui):
        self.playlist_yellow = ui.get("playlist_yellow")
        indigo.server.log("Yellow Key Music Playlist set to " + str(self.playlist_yellow), level=logging.DEBUG)

    # ########################################################################################
    # ##### Indigo UI Actions
    def send_beo4_key(self, action, device):
        device_id = int(device.address)
        key_code = int(action.props.get("keyCode", 0))
        destination = int(action.props.get("destination", 0))
        link = int(action.props.get("linkcmd", 0))
        if destination == 0x06:
            self.mlgw.send_beo4_cmd(device_id, destination, key_code, 0x01, link)
        else:
            self.mlgw.send_beo4_cmd(device_id, destination, key_code, 0x00, link)

    def send_beo4_src(self, action, device):
        device_id = int(device.address)
        key_code = int(action.props.get("keyCode", 0))
        destination = int(action.props.get("destination", 0))
        link = int(action.props.get("linkcmd", 0))
        if destination == 0x06:
            self.mlgw.send_beo4_cmd(device_id, destination, key_code, 0x01, link)
        else:
            self.mlgw.send_beo4_cmd(device_id, destination, key_code, 0x00, link)

    def send_br1_key(self, action, device):
        device_id = int(device.address)
        key_code = int(action.props.get("keyCode", 0))
        network_bit = int(action.props.get("netBit", 0))
        self.mlgw.send_beoremoteone_cmd(device_id, key_code, network_bit)

    def send_br1_src(self, action, device):
        device_id = int(device.address)
        key_code = str(action.props.get("keyCode", 0))
        network_bit = int(action.props.get("netBit", 0))
        try:
            key_code = CONST.beoremoteone_commanddict.get(key_code)
            self.mlgw.send_beoremoteone_select_source(device_id, key_code[0], key_code[1], network_bit)
        except KeyError:
            pass

    def send_hip_cmd(self, action):
        zone = str(action.props.get("zone", 0))
        room = str(action.props.get("room", 0))
        device_type = str(action.props.get("devType", 0))
        device_id = str(action.props.get("deviceID", 0))
        hip_command = str(action.props.get("hip_cmd", 0))
        telegram = "c " + zone + "/" + room + "/" + device_type + "/" + device_id + "/" + hip_command
        if self.mlcli.isBLGW:
            self.blgw.send_cmd(telegram)

    def send_hip_cmd2(self, action):
        hip_command = str(action.props.get("hip_cmd", 0))
        if self.mlcli.isBLGW:
            self.blgw.send_cmd(hip_command)

    def send_hip_query(self, action):
        zone = str(action.props.get("zone", 0))
        room = str(action.props.get("room", 0))
        device_type = str(action.props.get("devType", 0))
        device_id = str(action.props.get("deviceID", 0))
        if self.mlcli.isBLGW:
            self.blgw.query(zone, room, device_type, device_id)

    def send_bnr(self, action):
        cmd_type = str(action.props.get("cmd_type", 0))
        command = str(action.props.get("bnr_cmd", 0))
        cmd_data = str(action.props.get("cmd_data", 0))
        header = ''     # {'Content-Type': 'application/json'}

        try:
            if cmd_type == "GET":
                response = requests.get(url=command, headers=header, timeout=1)
            elif cmd_type == "POST":
                response = requests.post(url=command, headers=header, data=cmd_data, timeout=1)
            if cmd_type == "PUT":
                response = requests.put(url=command, headers=header, data=cmd_data, timeout=1)
            else:
                response = ''

            if response.content:
                response = json.loads(response.content)
                indigo.server.log(json.dumps(response, indent=4), level=logging.DEBUG)
        except requests.ConnectionError as e:
            indigo.server.log("Unable to process BeoNetRemote Command - " + str(e), level=logging.ERROR)

    def request_state_update(self, action, device):
        action_id = str(action.props.get("id", 0))
        zone = str(device.pluginProps['zone'])
        room = str(device.pluginProps['room'])
        device_type = "AV renderer"
        device_id = str(device.name)
        if self.mlcli.isBLGW:
            self.blgw.query(zone, room, device_type, device_id)

    def send_virtual_button(self, action):
        button_id = int(action.props.get("buttonID", 0))
        button_action = int(action.props.get("action", 0))
        self.mlgw.send_virtualbutton(button_id, button_action)

    def post_notification(self, action):
        title = str(action.props.get("title", 0))
        body = str(action.props.get("body", 0))
        self.iTunes.notify(body, title)

    def all_standby(self, action):
        self.mlgw.send_beo4_cmd(1, CONST.CMDS_DEST.get("ALL PRODUCTS"), CONST.BEO4_CMDS.get("STANDBY"))

    def request_serial_number(self):
        self.mlgw.get_serial()

    def request_device_update(self):
        if self.mlcli.isBLGW:
            self.blgw.query(dev_type="AV renderer")

    def reset_clients(self):
        self.check_connection(self.mlgw)
        self.check_connection(self.mlcli)

        if self.mlcli.isBLGW:
            self.check_connection(self.blgw)
        else:
            self.check_connection(self.mltn)

    # ########################################################################################
    # ##### Indigo UI Events
    def light_key(self, message):
        room = message['room_number']
        key_code = CONST.BEO4_CMDS.get(message['command'].upper())

        for trigger in self.triggers:
            props = trigger.globalProps["uk.co.lukes_plugins.BeoGateway.plugin"]
            if trigger.pluginTypeId == "lightKey" and \
                    (props["room"] == str(99) or props["room"] == str(room)) and \
                    props["keyCode"] == str(key_code):
                indigo.server.log("Executing Trigger: " + trigger.name, level=logging.DEBUG)
                indigo.trigger.execute(trigger)
                break

    def control_key(self, message):
        room = message['room_number']
        key_code = CONST.BEO4_CMDS.get(message['command'].upper())

        for trigger in self.triggers:
            props = trigger.globalProps["uk.co.lukes_plugins.BeoGateway.plugin"]
            if trigger.pluginTypeId == "controlKey" and \
                    (props["room"] == str(99) or props["room"] == str(room)) and \
                    props["keyCode"] == str(key_code):
                indigo.server.log("Executing Trigger: " + trigger.name, level=logging.DEBUG)
                indigo.trigger.execute(trigger)
                break

    def beo4_key(self, message):
        source = message['State_Update']['source']
        source_type = message['State_Update']['source']
        key_code = CONST.BEO4_CMDS.get(message['State_Update']['command'].upper())

        for trigger in self.triggers:
            props = trigger.globalProps["uk.co.lukes_plugins.BeoGateway.plugin"]
            if trigger.pluginTypeId == "beo4Key" and props["keyCode"] == str(key_code):
                if props["sourceType"] == "Any Source":
                    indigo.trigger.execute(trigger)
                    break
                elif props["sourceType"] == "Any Audio" and "AUDIO" in source_type:
                    indigo.trigger.execute(trigger)
                    break
                elif props["sourceType"] == "Any Audio" and "AUDIO" in source_type:
                    indigo.trigger.execute(trigger)
                    break
                elif props["sourceType"] == source:
                    indigo.trigger.execute(trigger)
                    break

    def virtual_button(self, message):
        button_id = message['button']
        action = message['action']
        for trigger in self.triggers:
            props = trigger.globalProps["uk.co.lukes_pugins.mlgw.plugin"]
            if trigger.pluginTypeId == "virtualButton" and \
                    props["buttonID"] == str(button_id) and \
                    props["action"] == str(action):
                indigo.trigger.execute(trigger)
                break

    # ########################################################################################
    # ##### Indigo UI Device Controls
    def actionControlDevice(self, action, node):
        """ Callback Method to Control a Relay Device. """
        if action.deviceAction == indigo.kDeviceAction.TurnOn:
            self._dev_on(node)
        elif action.deviceAction == indigo.kDeviceAction.TurnOff:
            self._dev_off(node)
        elif action.deviceAction == indigo.kDeviceAction.Toggle:
            if node.states["onOffState"]:
                self._dev_off(node)
            else:
                self._dev_on(node)
        elif action.deviceAction == indigo.kDeviceAction.RequestStatus:
            self._status_request(node)

    def _dev_on(self, node):
        indigo.server.log(node.name + " turned On")

        # Get a local copy of the gateway states from server
        active_renderers = self.gateway.states['AudioRenderers']
        active_source = self.gateway.states['currentAudioSource']
        active_sourceName = self.gateway.states['currentAudioSourceName']

        if self.debug:
            indigo.server.log('Active renderers: ' + active_renderers, level=logging.DEBUG)
            indigo.server.log('Active Audio Source: ' + active_source, level=logging.DEBUG)

        # Join if music already playing
        if active_renderers != '' and active_source != 'Unknown':
            # Send Beo4 command
            source = active_source
            self.mlgw.send_beo4_cmd(
                int(node.address),
                int(CONST.CMDS_DEST.get("AUDIO SOURCE")),
                int(CONST.BEO4_CMDS.get(source))
            )

            # Update device states
            sourceName = active_sourceName
            key_value_list = [
                {'key': 'onOffState', 'value': True},
                {'key': 'playState', 'value': 'Play'},
                {'key': 'source', 'value': sourceName},
                {'key': 'mute', 'value': False},
            ]

            if self.debug:
                indigo.server.log(
                    node.name + " joining current audio experience " + sourceName + " (" + source +
                    "). Joining active renderer(s): " + active_renderers,
                    level=logging.DEBUG
                )

        # Otherwise start default music source
        else:
            # Send Beo4 command
            source = self.default_audio_source
            self.mlgw.send_beo4_cmd(
                int(node.address),
                int(CONST.CMDS_DEST.get("AUDIO SOURCE")),
                int(CONST.BEO4_CMDS.get(source))
            )

            # Update device states
            sourceName = dict(CONST.available_sources).get(self.default_audio_source)
            key_value_list = [
                {'key': 'onOffState', 'value': True},
                {'key': 'playState', 'value': 'Play'},
                {'key': 'source', 'value': sourceName},
                {'key': 'mute', 'value': False},
            ]

            if self.debug:
                indigo.server.log(
                    node.name + " starting audio experience " + sourceName + " (" + source + ").",
                    level=logging.DEBUG
                )

        # Update states on server
        node.updateStatesOnServer(key_value_list)
        node.updateStateImageOnServer(indigo.kStateImageSel.AvPlaying)

        # Add device to active renderers lists and update gateway
        self.add_to_renderers_list(node.name, 'Audio')
        key_value_list = [
            {'key': 'currentAudioSource', 'value': source},
            {'key': 'currentAudioSourceName', 'value': sourceName},
        ]
        self.gateway.updateStatesOnServer(key_value_list)

    def _dev_off(self, node):
        indigo.server.log(node.name + " turned Off")

        # Send Beo4 command
        self.mlgw.send_beo4_cmd(
            int(node.address),
            int(CONST.CMDS_DEST.get("AUDIO SOURCE")),
            int(CONST.BEO4_CMDS.get('STANDBY'))
        )

        # Update states to standby values
        node.updateStatesOnServer(CONST.standby_state)
        node.updateStateImageOnServer(indigo.kStateImageSel.PowerOff)

        # Remove device from active renderers lists
        self.remove_from_renderers_list(node.name, 'All')

    def _status_request(self, node):
        if node.pluginProps['serial_no'] == 'NA':   # Check if this is a NetLink device: if no serial number then false
            # Potentially send a status update command but these may only work over 2 way IR, not the MasterLink
            self.mlgw.send_beo4_cmd(
                int(node.address),
                int(CONST.CMDS_DEST.get("AUDIO SOURCE")),
                int(CONST.BEO4_CMDS.get("STATUS"))
            )

            indigo.server.log(node.name + " does not support status requests")
        else:   # If netlink, request a status update
            self.blgw.query(dev_type="AV renderer", device=node.name)

    # ########################################################################################
    # Define callback function for message return from B&O Gateway
    def cb(self, name, header, payload, message):
        # ########################################################################################
        # Message handler
        # Handle Beo4 Command Events
        try:
            if message['payload_type'] == "BEO4_KEY":
                self.beo4_key(message)
        except KeyError:
            pass

        # Handle Light and Command Events
        try:
            if message['Type'] == "LIGHT COMMAND":
                self.light_key(message)
            elif message['Type'] == "CONTROL COMMAND":
                self.control_key(message)
        except KeyError:
            pass

        # Handle Virtual Button Events
        try:
            if message['payload_type'] == "MLGW virtual button event":
                self.virtual_button(message)
        except KeyError:
            pass

        # Handle all standby events
        try:
            if message["command"] == "All Standby":
                for node in indigo.devices.iter('uk.co.lukes_plugins.BeoGateway.plugin.AVrenderer'):
                    node.updateStatesOnServer(CONST.standby_state)
                    node.updateStateImageOnServer(indigo.kStateImageSel.PowerOff)

                indigo.devices['Bang and Olufsen Gateway'].updateStatesOnServer(CONST.gw_all_stb)
        except KeyError:
            pass

        # Handle AV Events
        try:
            # Use regular incoming messages to sync nowPlaying data
            if self.gateway.states['AudioRenderers'] != '' and \
                    self.gateway.states['currentAudioSource'] == str(self.itunes_source) and \
                    self.itunes_control:
                self._get_itunes_track_info(message)

            # For messages of type AV RENDERER, scan keys to update device states
            if message["Type"] == "AV RENDERER":
                # Tidy up messages
                self.av_sanitise(message)
                # Filter messages that don't constitute meaningful state updates
                actionable = self.filter_messages(message)
                if self.debug:
                    indigo.server.log("Process message: " + str(actionable), level=logging.WARNING)
                if actionable:
                    # Keep track of what sources are playing on the network
                    self.src_tracking(message)
                    # Update individual devices based on updates
                    self.dev_update(message)
        except KeyError:
            pass

        # Report message content to log
        if self.verbose:
            if 'State_Update' in message and 'CONNECTION' in message['State_Update']:
                # Don't print pong responses from regular client ping to check sockets are open -
                # approx every 600 seconds
                pass
            elif 'Device' in message and message['Device'] == 'Clock':
                # Don't print the Clock sync telegrams from the HIP -
                # approx every 60 seconds
                pass
            elif 'payload_type' in message and message['payload_type'] == '0x14':
                # Don't print the Clock sync telegrams from the ML -
                # approx every 6 seconds
                pass
            elif 'payload_type' in message and message['payload_type'] == 'CLOCK' and not self.debug:
                # Don't print the Clock message telegrams from the ML
                pass
            else:
                self.message_log(name, header, payload, message)

        # Report Thread Count
        if self.debug:
            thread_count = int(threading.active_count())
            if thread_count > 0:
                indigo.server.log("Current Thread Count = " + str(thread_count), level=logging.DEBUG)

    # ########################################################################################
    # AV Handler Functions

    # #### Message Conditioning
    def av_sanitise(self, message):
        # Sanitise AV messages
        try:  # Check for missing source information
            if message['State_Update']['source'] in [None, 'None', '']:
                message['State_Update']['source'] = 'Unknown'
                message['State_Update']['sourceName'] = 'Unknown'

                # Update for standby condition
                message['State_Update']['state'] = "Standby"
        except KeyError:
            pass

        try:  # Check for unknown state
            if message['State_Update']['state'] in [None, 'None', '']:
                message['State_Update']['state'] = 'Unknown'
        except KeyError:
            pass

        try:  # Sanitise unknown Channel/Tracks
            if message['State_Update']['nowPlayingDetails']['channel_track'] in [0, 255, '0', '255']:
                del message['State_Update']['nowPlayingDetails']['channel_track']
        except KeyError:
            pass

        try:    # Add sourceName if not in message block
            if 'sourceName' not in message['State_Update']:
                # Find the sourceName from the source list for this device
                if 'Device' in message:     # If device known use local source data
                    self.find_source_name(message['State_Update']['source'],
                                          indigo.devices[message['Device']].pluginProps['sources'])
                else:   # If device not known use global source data
                    message['State_Update']['sourceName'] = \
                        dict(CONST.available_sources).get(message['State_Update']['source'])
        except KeyError:
            pass

        try:    # Catch GOTO_SOURCE commands and set the goto_flag
            if message['payload_type'] == 'GOTO_SOURCE':
                self.goto_flag = datetime.now()
                if self.debug:
                    indigo.server.log("GOTO_SOURCE command received - goto_flag set", level=logging.WARNING)
        except KeyError:
            pass

    def filter_messages(self, message):
        # Filter state updates that are:
        # 1. Standby states that are received between source changes:
        # If device is changing source the state changes as follows [Old Source -> Standby -> New Source].
        # If the standby condition is processed, the New Source state will be filtered by the condition below
        #
        # 2. Play states that received <1.5 seconds after standby state set:
        # Some messages come in on the ML and HIP protocols relating to previous state etc.
        # These can be ignored to avoid false states for the indigo devices
        try:
            for node in indigo.devices.iter('uk.co.lukes_plugins.BeoGateway.plugin.AVrenderer'):
                if node.name == message['Device']:

                    # Get time since last state update for this device
                    time_delta1 = datetime.now() - node.lastChanged
                    time_delta1 = time_delta1.total_seconds()
                    # Get time since last GOTO_SOURCE command
                    time_delta2 = datetime.now() - self.goto_flag
                    time_delta2 = time_delta2.total_seconds()

                    # If standby command received <2.0 seconds after GOTO_SOURCE command , ignore
                    if 'state' in message['State_Update'] and message['State_Update']['state'] == "Standby" \
                            and time_delta2 < 2.0:                                                  # Condition 1
                        if self.debug:
                            indigo.server.log(message['Device'] + " ignoring Standby: " + str(round(time_delta2, 2)) +
                                              " seconds elapsed since GOTO_STATE command - ignoring message!",
                                              level=logging.DEBUG)
                        return False

                    # If message received <1.5 seconds after standby state, ignore
                    elif node.states['playState'] == "Standby" and time_delta1 < 1.5:               # Condition 2
                        if self.debug:
                            indigo.server.log(message['Device'] + " in Standby: " + str(round(time_delta1, 2)) +
                                              " seconds elapsed since last state update - ignoring message!",
                                              level=logging.DEBUG)
                        return False
                    else:
                        return True
        except KeyError:
            return False

    # #### State tracking
    def src_tracking(self, message):
        # Track active renderers via gateway device
        try:
            # If new source is an audio source then update the gateway accordingly
            if message['State_Update']['source'] in CONST.source_type_dict.get('Audio Sources'):
                try:
                    # Keep track of which devices are playing audio sources
                    if message['Device'] not in self.gateway.states['AudioRenderers'] and \
                            message['State_Update']['state'] not in ['Standby', 'Unknown', 'None']:

                        # Log current audio source (MasterLink allows a single audio source for distribution)
                        source = message['State_Update']['source']
                        sourceName = dict(CONST.available_sources).get(source)

                        self.gateway.updateStateOnServer('currentAudioSource', value=source)
                        self.gateway.updateStateOnServer('currentAudioSourceName', value=sourceName)

                        try:
                            self.gateway.updateStateOnServer('nowPlaying', value=message['State_Update']['nowPlaying'])
                        except KeyError:
                            self.gateway.updateStateOnServer('nowPlaying', value='Unknown')

                        self.add_to_renderers_list(message['Device'], 'Audio')

                    # Remove device from Video Renderers list if it is on there
                    if message['Device'] in self.gateway.states['VideoRenderers']:
                        self.remove_from_renderers_list(message['Device'], 'Video')

                except KeyError:
                    pass

                # If source is N.Music then control accordingly
                if message['State_Update']['source'] == str(self.itunes_source) and self.itunes_control:
                    self.iTunes_transport_control(message)

            # If new source is an video source then update the gateway accordingly
            elif message['State_Update']['source'] in CONST.source_type_dict.get('Video Sources'):
                try:
                    # Keep track of which devices are playing video sources
                    if message['Device'] not in self.gateway.states['VideoRenderers'] and \
                            message['State_Update']['state'] not in ['Standby', 'Unknown', 'None']:
                        self.add_to_renderers_list(message['Device'], 'Video')

                    # Remove device from Audio Renderers list if it is on there
                    if message['Device'] in self.gateway.states['AudioRenderers']:
                        self.remove_from_renderers_list(message['Device'], 'Audio')

                except KeyError:
                    pass
        except KeyError:
            pass

    def dev_update(self, message):
        # Update device states
        try:
            for node in indigo.devices.iter('uk.co.lukes_plugins.BeoGateway.plugin.AVrenderer'):
                if node.name == message['Device']:
                    # Handle Standby state
                    if message['State_Update']['state'] == "Standby":
                        # Update states to standby values
                        node.updateStatesOnServer(CONST.standby_state)
                        node.updateStateImageOnServer(indigo.kStateImageSel.PowerOff)

                        # Remove the device from active renderers list
                        self.remove_from_renderers_list(message['Device'], 'All')

                        # Post state update in Apple Notification Centre
                        if self.notifymode:
                            self.iTunes.notify(node.name + " now in Standby", "Device State Update")
                        return

                    # If device not in standby then update its state information
                    # get current states as list        # Index
                    last_state = [
                        node.states['playState'],       # 0
                        node.states['source'],          # 1
                        node.states['nowPlaying'],      # 2
                        node.states['channelTrack'],    # 3
                        node.states['volume'],          # 4
                        node.states['mute'],            # 5
                        node.states['onOffState']       # 6
                    ]

                    # Initialise new state list - the device is not in standby so it must be on
                    new_state = last_state[:]
                    new_state[6] = True

                    # Update device states with values from message
                    if 'state' in message['State_Update']:
                        if message['State_Update']['state'] not in ['None', 'Standby', '', None]:
                            if last_state[0] == 'Standby' and message['State_Update']['state'] == 'Unknown':
                                new_state[0] = 'Play'
                            elif last_state[0] != 'Standby' and message['State_Update']['state'] == 'Unknown':
                                pass
                            else:
                                new_state[0] = message['State_Update']['state']

                    if 'sourceName' in message['State_Update'] and message['State_Update']['sourceName'] != 'Unknown':
                        # Sanitise source name to avoid indigo key errors (remove whitespace)
                        source_name = message['State_Update']['sourceName'].strip().replace(" ", "_")
                        new_state[1] = source_name

                    if 'nowPlaying' in message['State_Update']:
                        # Update now playing information unless the state value is empty or unknown
                        if message['State_Update']['nowPlaying'] not in [0, '0', '', 'Unknown']:
                            new_state[2] = message['State_Update']['nowPlaying']
                        # If the state value is empty/unknown and the source has not changed then no update required
                        elif new_state[1] != last_state[1]:
                            # If the state has changed and the value is unknown, then set as "Unknown"
                            new_state[2] = 'Unknown'

                    if 'nowPlayingDetails' in message['State_Update'] and \
                            'channel_track' in message['State_Update']['nowPlayingDetails']:
                        new_state[3] = message['State_Update']['nowPlayingDetails']['channel_track']
                    elif new_state[1] != last_state[1]:
                        # If the state has changed and the value is unknown, then set as "Unknown"
                        new_state[2] = 0

                    if 'volume' in message['State_Update']:
                        new_state[4] = message['State_Update']['volume']

                    try:    # Check for mute state
                        if message['State_Update']['sound_status']['mute_status'] == 'Muted':
                            new_state[5] = True
                        else:
                            new_state[5] = False
                    except KeyError:
                        new_state[5] = False

                    if new_state != last_state:
                        # Update states on server
                        key_value_list = [
                            {'key': 'playState', 'value': new_state[0]},
                            {'key': 'source', 'value': new_state[1]},
                            {'key': 'nowPlaying', 'value': new_state[2]},
                            {'key': 'channelTrack', 'value': new_state[3]},
                            {'key': 'volume', 'value': new_state[4]},
                            {'key': 'mute', 'value': new_state[5]},
                            {'key': 'onOffState', 'value': new_state[6]},
                        ]
                        node.updateStatesOnServer(key_value_list)

                        # Post notifications Notifications
                        if self.notifymode:
                            self.notifications(node.name, last_state, new_state)

                        # Update state image on server
                        if new_state[0] == "Stopped":
                            node.updateStateImageOnServer(indigo.kStateImageSel.AvPaused)
                        elif new_state[0] not in ['None', 'Unknown', 'Standby', '', None]:
                            node.updateStateImageOnServer(indigo.kStateImageSel.AvPlaying)

                        # If audio source active, update any other active audio renderers accordingly
                        try:
                            if new_state[0] not in ['None', 'Unknown', 'Standby', '', None] and \
                                    message['State_Update']['source'] in CONST.source_type_dict.get('Audio Sources'):
                                self.all_audio_nodes_update(new_state, node.name, message['State_Update']['source'])
                        except KeyError:
                            pass

                        break
        except KeyError:
            pass

    def all_audio_nodes_update(self, new_state, dev, source):
        # Loop over all active audio renderers to update them with the latest audio state
        for node in indigo.devices.iter('uk.co.lukes_plugins.BeoGateway.plugin.AVrenderer'):
            if node.name in self.gateway.states['AudioRenderers'] and node.name != dev:
                # Get current state of this node
                last_state = [
                    node.states['playState'],
                    node.states['source'],
                    node.states['nowPlaying'],
                    node.states['channelTrack'],
                    node.states['volume'],
                    node.states['mute'],
                ]

                if last_state[:4] != new_state[:4]:
                    # Update the play state for active Audio renderers if new values are different from current ones
                    key_value_list = [
                        {'key': 'onOffState', 'value': True},
                        {'key': 'playState', 'value': new_state[0]},
                        {'key': 'source', 'value': new_state[1]},
                        {'key': 'nowPlaying', 'value': new_state[2]},
                        {'key': 'channelTrack', 'value': new_state[3]},
                        {'key': 'mute', 'value': False},
                    ]
                    node.updateStatesOnServer(key_value_list)
                    node.updateStateImageOnServer(indigo.kStateImageSel.AvPlaying)

        # Update the gateway
        if self.gateway.states['currentAudioSourceName'] != new_state[1]:
            # If the source has changed, update both source and nowPlaying
            sourceName = new_state[1]

            key_value_list = [
                {'key': 'currentAudioSource', 'value': source},
                {'key': 'currentAudioSourceName', 'value': sourceName},
                {'key': 'nowPlaying', 'value': new_state[2]},
            ]
            self.gateway.updateStatesOnServer(key_value_list)

        elif self.gateway.states['nowPlaying'] != new_state[2] and new_state[2] not in ['', 'Unknown']:
            # If the source has not changed, and nowPlaying is not Unknown, update nowPlaying
            self.gateway.updateStateOnServer('nowPlaying', value=new_state[2])

    # #### Active renderer list maintenance
    def add_to_renderers_list(self, dev, av):
        if av == "Audio":
            renderer_list = 'AudioRenderers'
            renderer_count = 'nAudioRenderers'
        else:
            renderer_list = 'VideoRenderers'
            renderer_count = 'nVideoRenderers'

        # Retrieve the renderers and convert from string to list
        renderers = self.gateway.states[renderer_list].split(', ')

        # Sanitise the list for stray blanks
        if '' in renderers:
            renderers.remove('')

        # Add device to list if not already on there
        if dev not in renderers:
            renderers.append(dev)
            self.gateway.updateStateOnServer(renderer_list, value=', '.join(renderers))
            self.gateway.updateStateOnServer(renderer_count, value=len(renderers))

    def remove_from_renderers_list(self, dev, av):
        # Remove devices from renderers lists when the enter standby mode
        if av in ['Audio', 'All']:
            if dev in self.gateway.states['AudioRenderers']:
                renderers = self.gateway.states['AudioRenderers'].split(', ')
                renderers.remove(dev)

                self.gateway.updateStateOnServer('AudioRenderers', value=', '.join(renderers))
                self.gateway.updateStateOnServer('nAudioRenderers', value=len(renderers))

        if av in ['Video', 'All']:
            if dev in self.gateway.states['VideoRenderers']:
                renderers = self.gateway.states['VideoRenderers'].split(', ')
                renderers.remove(dev)

                self.gateway.updateStateOnServer('VideoRenderers', value=', '.join(renderers))
                self.gateway.updateStateOnServer('nVideoRenderers', value=len(renderers))

        # If no audio sources are playing then update the gateway states
        if self.gateway.states['AudioRenderers'] == '':
            key_value_list = [
                {'key': 'AudioRenderers', 'value': ''},
                {'key': 'nAudioRenderers', 'value': 0},
                {'key': 'currentAudioSource', 'value': 'Unknown'},
                {'key': 'currentAudioSourceName', 'value': 'Unknown'},
                {'key': 'nowPlaying', 'value': 'Unknown'},
            ]
            self.gateway.updateStatesOnServer(key_value_list)

            # If no AV renderers are playing N.Music, stop iTunes playback
            if self.itunes_control:
                self.iTunes.stop()

    # #### Helper functions
    @staticmethod
    def find_source_name(source, sources):
        # Get the sourceName for source
        for source_name in sources:
            if sources[source_name]['source'] == str(source):
                return str(sources[source_name]).split()[0]

        # if source list exhausted and no valid name found return Unknown
        return 'Unknown'

    @staticmethod
    # Get the source ID for sourceName
    def get_source(sourceName, sources):
        for source_name in sources:
            if source_name == sourceName:
                return str(sources[source_name]['source'])

        # if source list exhausted and no valid name found return Unknown
        return 'Unknown'

    # ########################################################################################
    # Apple Music Control and feedback
    def iTunes_transport_control(self, message):
        # Transport controls for iTunes
        try:  # If N.MUSIC command, trigger appropriate self.iTunes control
            if message['State_Update']['state'] not in ["", "Standby"]:
                self.iTunes.play(self.playlist_default)
        except KeyError:
            pass

        try:  # If N.MUSIC selected and Beo4 command received then run appropriate transport commands
            if message['State_Update']['command'] == "Go/Play":
                self.iTunes.play(self.playlist_default)

            elif message['State_Update']['command'] == "Stop":
                self.iTunes.pause()

            elif message['State_Update']['command'] == "Exit":
                self.iTunes.stop()

            elif message['State_Update']['command'] == "Step Up":
                self.iTunes.next_track()

            elif message['State_Update']['command'] == "Step Down":
                self.iTunes.previous_track()

            elif message['State_Update']['command'] == "Wind":
                self.iTunes.wind(15)

            elif message['State_Update']['command'] == "Rewind":
                self.iTunes.rewind(-15)

            elif message['State_Update']['command'] == "Shift-1/Random":
                self.iTunes.shuffle()

            elif "Digit-" in message['State_Update']['command']:
                rating = int(message['State_Update']['command'][-1:]) * 100/9
                self.iTunes.set_rating(int(rating))


            # If 'Info' pressed - update track info
            elif message['State_Update']['command'] == "Info":
                track_info = self.iTunes.get_current_track_info()
                if track_info[0] not in [None, 'None']:
                    indigo.server.log(
                        "\n\t----------------------------------------------------------------------------"
                        "\n\tiTUNES CURRENT TRACK INFO:"
                        "\n\t============================================================================"
                        "\n\tNow playing: '" + track_info[0] + "'"
                        "\n\t             by " + track_info[2] +
                        "\n\t             from the album '" + track_info[1] + "'"
                        "\n\t----------------------------------------------------------------------------"
                        "\n\tACTIVE AUDIO RENDERERS: " + str(self.gateway.states['AudioRenderers']) + "\n\n",
                        level=logging.DEBUG
                    )
                    s = 'say ' + track_info[0] + ', by ' + track_info[2] + ', from the album, ' + track_info[1]
                    os.system(s)

                self.iTunes.notify(
                    "Now playing: '" + track_info[0] +
                    "' by " + track_info[2] +
                    "from the album '" + track_info[1] + "'",
                    "Apple Music Track Info:"
                )

            # If 'Guide' pressed - print instructions to indigo log
            elif message['State_Update']['command'] == "Guide":
                indigo.server.log(
                    "\n\t----------------------------------------------------------------------------"
                    "\n\tBeo4/BeoRemote One Control of Apple Music"
                    "\n\tKey mapping guide: [Key : Action]"
                    "\n\t============================================================================"
                    "\n\n\t** BASIC TRANSPORT CONTROLS **"
                    "\n\tGO/PLAY        : Play"
                    "\n\tSTOP/Pause     : Pause"
                    "\n\tEXIT           : Stop"
                    "\n\tStep Up/P+     : Next Track"
                    "\n\tStep Down/P-   : Previous Track"
                    "\n\tWind           : Scan Forwards 15 Seconds"
                    "\n\tRewind         : Scan Backwards 15 Seconds"
                    "\n\n\t** DIGITS **"
                    "\n\tDigit  0       : Rate Track at 0 (0%), dislike it, and disable it from playback"
                    "\n\tDigits 1 to 8  : Rate Track from 1 (10%) to 8 (90%)"
                    "\n\tDigit  9       : Rate Track at 9 (100%) and 'love'' it"
                    "\n\n\t** FUNCTIONS **"
                    "\n\tShift-1/Random : Toggle Shuffle"
                    "\n\tINFO           : Display Track Info for Current Track"
                    "\n\tGUIDE          : This Guide"
                    "\n\n\t** ADVANCED CONTROLS **"
                    "\n\tGreen          : Shuffle Playlist '" + self.playlist_green + "'"
                    "\n\tYellow         : Shuffle Playlist '" + self.playlist_yellow + "'"
                    "\n\tRed            : More of the Same"
                    "\n\tBlue           : Play the Album that the Current Track Resides On\n\n",
                    level=logging.DEBUG
                )

            # If colour key pressed, execute the appropriate applescript
            elif message['State_Update']['command'] == "Green":
                # Play a specific playlist - defaults to Recently Played
                # script = ASBridge.__file__[:-12] + '/Scripts/green.scpt'
                # self.iTunes.run_script(script, self.debug)
                self.iTunes.play_playlist(self.playlist_green)

            elif message['State_Update']['command'] == "Yellow":
                # Play a specific playlist - defaults to URL Radio stations
                # script = ASBridge.__file__[:-12] + '/Scripts/yellow.scpt'
                # self.iTunes.run_script(script, self.debug)
                self.iTunes.play_playlist(self.playlist_yellow)

            elif message['State_Update']['command'] == "Blue":
                # Play the current album
                script = ASBridge.__file__[:-12] + '/Scripts/blue.scpt'
                self.iTunes.run_script(script, self.debug)

            elif message['State_Update']['command'] in ["0xf2", "Red", "MOTS"]:
                # More of the same (start a playlist with just current track and let autoplay find similar tunes)
                script = ASBridge.__file__[:-12] + '/Scripts/red.scpt'
                self.iTunes.run_script(script, self.debug)
        except KeyError:
            pass

    def _get_itunes_track_info(self, message):
        track_info = self.iTunes.get_current_track_info()
        if track_info[0] not in [None, 'None']:
            # Construct track info string
            track_info_ = "'" + track_info[0] + "' by " + track_info[2] + " from the album '" + track_info[1] + "'"

            # Add now playing info to the message block
            if 'Type' in message and message['Type'] == "AV RENDERER" and 'source' in message['State_Update'] \
                    and message['State_Update']['source'] == str(self.itunes_source) and \
                    'nowPlaying' in message['State_Update']:
                message['State_Update']['nowPlaying'] = track_info_
                message['State_Update']['nowPlayingDetails']['channel_track'] = int(track_info[3])

            # Print track info to log if trackmode is set to true (via config UI)
            src = dict(CONST.available_sources).get(self.itunes_source)
            if self.gateway.states['currentAudioSource'] == str(self.itunes_source) and \
                    track_info_ != self.gateway.states['nowPlaying'] and self.trackmode:
                indigo.server.log("\n\t----------------------------------------------------------------------------"
                                  "\n\tiTUNES CURRENT TRACK INFO:"
                                  "\n\t============================================================================"
                                  "\n\tNow playing: '" + track_info[0] + "'"
                                  "\n\t             by " + track_info[2] +
                                  "\n\t             from the album '" + track_info[1] + "'"
                                  "\n\t----------------------------------------------------------------------------"
                                  "\n\tACTIVE AUDIO RENDERERS: " + str(self.gateway.states['AudioRenderers']) + "\n\n")

                if self.notifymode:
                    # Post track information to Apple Notification Centre
                    self.iTunes.notify(track_info_ + " from source " + src,
                                       "Now Playing:")

            # Update nowPlaying on the gateway device
            if track_info_ != self.gateway.states['nowPlaying'] and \
                    self.gateway.states['currentAudioSource'] == str(self.itunes_source):
                self.gateway.updateStateOnServer('nowPlaying', value=track_info_)

                # Update info on active Audio Renderers
                for node in indigo.devices.iter('uk.co.lukes_plugins.BeoGateway.plugin.AVrenderer'):
                    if node.name in self.gateway.states['AudioRenderers']:
                        key_value_list = [
                            {'key': 'onOffState', 'value': True},
                            {'key': 'playState', 'value': 'Play'},
                            {'key': 'source', 'value': src},
                            {'key': 'nowPlaying', 'value': track_info_},
                            {'key': 'channelTrack', 'value': int(track_info[3])},
                        ]
                        node.updateStatesOnServer(key_value_list)
                        node.updateStateImageOnServer(indigo.kStateImageSel.AvPlaying)

    # ########################################################################################
    # Message Reporting
    @staticmethod
    def message_log(name, header, payload, message):
        # Set reporting level for message logging
        try:        # CLOCK messages are filtered except in debug mode
            if message['payload_type'] == 'CLOCK':
                debug_level = logging.DEBUG
            else:   # Everything else is for INFO
                debug_level = logging.INFO
        except KeyError:
            debug_level = logging.INFO

        # Pretty formatting - convert to JSON format then remove braces
        message = json.dumps(message, indent=4)
        for r in (('"', ''), (',', ''), ('{', ''), ('}', '')):
            message = str(message).replace(*r)

        # Print message data
        if len(payload) + 9 < 73:
            indigo.server.log("\n\t----------------------------------------------------------------------------" +
                              "\n\t" + name + ": <--DATA-RECEIVED!-<< " +
                              datetime.now().strftime("on %d/%m/%y at %H:%M:%S") +
                              "\n\t============================================================================" +
                              "\n\tHeader: " + header +
                              "\n\tPayload: " + payload +
                              "\n\t----------------------------------------------------------------------------" +
                              message, level=debug_level)
        elif 73 < len(payload) + 9 < 137:
            indigo.server.log("\n\t----------------------------------------------------------------------------" +
                              "\n\t" + name + ": <--DATA-RECEIVED!-<< " +
                              datetime.now().strftime("on %d/%m/%y at %H:%M:%S") +
                              "\n\t============================================================================" +
                              "\n\tHeader: " + header +
                              "\n\tPayload: " + payload[:66] + "\n\t\t" + payload[66:137] +
                              "\n\t----------------------------------------------------------------------------" +
                              message, level=debug_level)
        else:
            indigo.server.log("\n\t----------------------------------------------------------------------------" +
                              "\n\t" + name + ": <--DATA-RECEIVED!-<< " +
                              datetime.now().strftime("on %d/%m/%y at %H:%M:%S") +
                              "\n\t============================================================================" +
                              "\n\tHeader: " + header +
                              "\n\tPayload: " + payload[:66] + "\n\t\t" + payload[66:137] + "\n\t\t" + payload[137:] +
                              "\n\t----------------------------------------------------------------------------" +
                              message, level=debug_level)

    def notifications(self, name, last_state, new_state):
        # Post state information to the Apple Notification Centre
        # Information index:
        #   node.states['playState'],       # 0
        #   node.states['source'],          # 1
        #   node.states['nowPlaying'],      # 2
        #   node.states['channelTrack'],    # 3
        #   node.states['volume'],          # 4
        #   node.states['mute'],            # 5
        #   node.states['onOffState']       # 6

        # Don't post notification if nothing has changed
        if last_state == new_state:
            return

        # Source status information
        if last_state[0] != new_state[0] and new_state[0] == "Standby":  # Power off
            self.iTunes.notify(
                name + " now in Standby",
                "Device State Update"
            )
            return
        elif last_state[1] != new_state[1] and new_state[0] != "Standby":  # Source Update
            self.iTunes.notify(
                name + " now playing from source " + new_state[1],
                "Device State Update"
            )
            return
        elif last_state[0] != new_state[0] and new_state[0] == "Play":  # Power on
            self.iTunes.notify(
                name + " Active",
                "Device State Update"
            )
            return

        # Channel/Track information
        if new_state[2] not in [None, 'None', '', 0, '0', 'Unknown']:   # Now Playing Update
            self.iTunes.notify(
                new_state[2] + " from source " + new_state[1],
                name + " Now Playing:"
            )
        elif last_state[3] != new_state[3] and new_state[3] not in [0, 255, '0', '255']:  # Channel/Track Update
            self.iTunes.notify(
                name + " now playing channel/track " + new_state[3] + " from source " + new_state[1],
                "Device Channel/Track Information"
            )

    # ########################################################################################
    # Indigo Server Methods
    def startup(self):
        indigo.server.log(u"Startup called")

        # Download the config file from the gateway and initialise the devices
        config = MLCONFIG.MLConfig(self.host, self.user, self.pwd, self.debug)
        self.gateway = indigo.devices['Bang and Olufsen Gateway']

        # Create MLGW Protocol and ML_CLI Protocol clients (basic command listening)
        indigo.server.log('Creating MLGW Protocol Client...', level=logging.WARNING)
        self.mlgw = MLGW.MLGWClient(self.host, self.port[0], self.user, self.pwd, 'MLGW protocol', self.debug, self.cb)
        asyncore.loop(count=10, timeout=0.2)

        indigo.server.log('Creating ML Command Line Protocol Client...', level=logging.WARNING)
        self.mlcli = MLCLI.MLCLIClient(self.host, self.port[2], self.user, self.pwd,
                                       'ML command line interface', self.debug, self.cb)
        # Log onto the MLCLI client and ascertain the gateway model
        asyncore.loop(count=10, timeout=0.2)

        # Now MLGW and MasterLink Command Line Client are set up, retrieve MasterLink IDs of products
        config.get_masterlink_id(self.mlgw, self.mlcli)

        # If the gateway is a BLGW use the BLHIP protocol, else use the legacy MLHIP protocol
        if self.mlcli.isBLGW:
            indigo.server.log('Creating BLGW Home Integration Protocol Client...', level=logging.WARNING)
            self.blgw = BLHIP.BLHIPClient(self.host, self.port[1], self.user, self.pwd,
                                          'BLGW Home Integration Protocol', self.debug, self.cb)
            self.mltn = None
        else:
            indigo.server.log('Creating MLGW Home Integration Protocol Client...', level=logging.WARNING)
            self.mltn = MLtn.MLtnClient(self.host, self.port[2], self.user, self.pwd, 'ML telnet client',
                                        self.debug, self.cb)
            self.blgw = None

    # Connection polling
    def check_connection(self, client):
        last = round(time.time() - client.last_received_at, 2)
        # Reconnect if socket has disconnected, or if no response received to last ping
        if not client.is_connected or last > 60:
            indigo.server.log("\t" + client.name + ": Reconnecting!", level=logging.WARNING)
            client.handle_close()
            self.sleep(0.5)
            client.client_connect()

    # Indigo main program loop
    def runConcurrentThread(self):
        try:
            while True:
                # Ping all connections every 10 minutes to prompt messages on the network
                asyncore.loop(count=self.pollinterval, timeout=1)
                if self.mlgw.is_connected:
                    self.mlgw.ping()
                if self.mlcli.is_connected:
                    self.mlcli.ping()
                if self.mlcli.isBLGW:
                    if self.blgw.is_connected:
                        self.blgw.ping()
                else:
                    if self.mltn.is_connected:
                        self.mltn.ping()

                # Check the connections approximately every 10 minutes to keep sockets open
                asyncore.loop(count=5, timeout=1)
                self.check_connection(self.mlgw)
                self.check_connection(self.mlcli)
                if self.mlcli.isBLGW:
                    self.check_connection(self.blgw)
                else:
                    self.check_connection(self.mltn)

                self.sleep(0.5)

        except self.StopThread:
            raise asyncore.ExitNow('Server is quitting!')

    # Tidy up on shutdown
    def shutdown(self):
        indigo.server.log("Shutdown plugin")
        del self.mlgw
        del self.mlcli
        if self.mlcli.isBLGW:
            del self.blgw
        else:
            del self.mltn
        del self.iTunes
        raise asyncore.ExitNow('Server is quitting!')