Esempio n. 1
0
    def parse_message(self, message):
        try:
            data = json.loads(message)
            logging.debug(data)
            if "metadata" in data:
                logging.error(data["metadata"])
                md = Metadata()
                map_attributes(data["metadata"], md.__dict__,
                               VOLSPOTIFY_ATTRIBUTE_MAP)
                md.artUrl = self.cover_url(data["metadata"]["albumartId"])
                md.playerName = MYNAME
                self.control.metadata = md
            elif "position_ms" in data:
                pos = float(data["position_ms"]) / 1000
                self.control.metadata.set_position(pos)
            elif "volume" in data:
                logging.debug("ignoring volume data")
            elif "token" in data:
                logging.info("got access_token update")
                self.control.access_token = data["token"]
            else:
                logging.warn("don't know how to handle %s", data)

        except Exception as e:
            logging.error("error while parsing %s (%s)", message, e)
Esempio n. 2
0
    def get_meta(self):
        state = self.get_state()

        song = None
        if state in [STATE_PLAYING, STATE_PAUSED]:
            song = self.client.currentsong()

        md = Metadata()
        md.playerName = "mpd"

        if song is not None:
            map_attributes(song, md.__dict__, MPD_ATTRIBUTE_MAP)

        return md
Esempio n. 3
0
    def get_meta(self, name):
        """
        Return the metadata for the given player instance
        """
        try:
            device_prop = self.dbus_get_device_prop_interface(name)
            prop = device_prop.Get(
                "org.mpris.MediaPlayer2.Player", "Metadata")
            try:
                artist = array_to_string(prop.get("xesam:artist"))
            except:
                artist = None

            try:
                title = prop.get("xesam:title")
            except:
                title = None

            try:
                albumArtist = array_to_string(prop.get("xesam:albumArtist"))
            except:
                albumArtist = None

            try:
                albumTitle = prop.get("xesam:album")
            except:
                albumTitle = None

            try:
                artURL = prop.get("mpris:artUrl")
            except:
                artURL = None

            try:
                discNumber = prop.get("xesam:discNumber")
            except:
                discNumber = None

            try:
                trackNumber = prop.get("xesam:trackNumber")
            except:
                trackNumber = None

            md = Metadata(artist, title, albumArtist, albumTitle,
              artURL, discNumber, trackNumber)

            try:
                md.streamUrl = prop.get("xesam:url")
            except:
                pass

            try:
                md.trackId = prop.get("mpris:trackid")
            except:
                pass


            if (name.startswith(MPRIS_PREFIX)):
                md.playerName = name[len(MPRIS_PREFIX):]
            else:
                md.playerName = name

            return md

        except dbus.exceptions.DBusException as e:
            if "ServiceUnknown" in e.__class__.__name__:
                # unfortunately we can't do anything about this and
                # logging doesn't help, therefore just ignoring this case
                pass
                #  logging.warning("service %s disappered, cleaning up", e)
            else:
                logging.warning("no mpris data received %s", e.__class__.__name__)

            md = Metadata()
            md.playerName = self.playername(name)
            return md
Esempio n. 4
0
    def tmux_scraper(self):
        logging.info('tidalcontrol::tmux_scraper')
        cmd = 'docker exec -ti tidal_connect /usr/bin/tmux capture-pane -pS -10'
        stdout = subprocess.check_output(cmd.split())
        WINDOW_SIZE = 40
        WINDOW_COUNT = 2
        VALUE_MAP = {}

        for line in stdout.decode('utf-8').splitlines():
            if line.startswith('PlaybackState::'):
                VALUE_MAP['state'] = line.split('::')[1]
            # parse props
            if line.startswith('xx', WINDOW_SIZE - 1):
                for window_cnt in range(WINDOW_COUNT):
                    str_keyvals = (line[(WINDOW_SIZE * window_cnt) +
                                        1:(WINDOW_SIZE *
                                           (window_cnt + 1)) - 1].strip())

                    ar_props = str_keyvals.split(':')
                    if len(ar_props) > 1:
                        key = (ar_props[0].replace(' ', '_'))
                        value = ''.join(ar_props[1:]).strip()
                        sess_state_prefix = 'SessionState'
                        if value.startswith(sess_state_prefix):
                            value = value[len(sess_state_prefix):]
                        VALUE_MAP[key] = value
            # parse volume
            if line.endswith('#k'):
                value = line.strip()
                VALUE_MAP["volume"] = value.count("#")
        self.state = VALUE_MAP["state"]

        md = Metadata()
        md.playerName = "Tidal"
        md.artist = VALUE_MAP['artists']
        md.title = VALUE_MAP['title']
        md.albumTitle = VALUE_MAP['album_name']
        md.duration = VALUE_MAP['duration']
        md.artUrl = None
        md.externalArtUrl = None
        '''
        self.artist = artist
        self.title = title
        self.albumArtist = albumArtist
        self.albumTitle = albumTitle
        self.artUrl = artUrl
        self.externalArtUrl = None
        self.discNumber = discNumber
        self.tracknumber = trackNumber
        self.playerName = playerName
        self.playerState = playerState
        self.streamUrl = streamUrl
        self.playCount = None
        self.mbid = None
        self.artistmbid = None
        self.albummbid = None
        self.loved = None
        self.wiki = None
        self.loveSupported = Metadata.loveSupportedDefault
        self.tags = []
        self.skipped = False
        self.host_uuid = None
        self.releaseDate = None
        self.trackid = None
        self.hifiberry_cover_found=False
        self.duration=0
        self.time=0
        self.position=0 # poosition in seconds
        self.positionupdate=time() # last time position has been updated
        '''

        self.meta = md