Plugins: imms.2.py

# Copyright 2007 Joonatan Kaartinen <jkaartinen@iki.fi>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation
#
# $Id$

import gtk, widgets
import gobject, config, player
import threading
import socket
import os, select

from plugins.events import EventPlugin
from library import library

verbose = True
def log(msg):
    if verbose:
        print "[IMMS] ", msg, "\n"

class IMMS(EventPlugin):
    PLUGIN_ID = "IMMS"
    PLUGIN_NAME = _("Intelligent Multimedia Management System")
    PLUGIN_VERSION = "0.2.2"
    PLUGIN_ICON = gtk.STOCK_CONNECT
    PLUGIN_DESC = ("Completely transparently keeps track of your listening "
                   "habits, like Auto Rating plugin but uses the external "
                   "program immsd for the actual work.\n\nFor more "
                   "information, see the website:\n"
                   "http://www.luminal.org/wiki/index.php/IMMS/IMMS\n\n"
                   "Warning, imms system's internal database is used for "
                   "ratings. If this plugin is activated, quod libet's own "
                   "ratings stop affecting weighted playback.")
                   
    socket = None
    connected = False
    modelproxy = None
    order_id = None
    songs_id = None
    songhandler_id = None
    activated = False
    enable = False
    thread = None
    immsqueue = []
    song_manual = False
    songlist_sent = False
    songs = []
    active_songs = []
    songdic = {}
    use_xidle = None
    sent_queuerequest = False
    __buffer = ""

    def __init__(self):
        log("Initializing.")
        try:
            self.use_xidle = config.get("plugins","imms_use_xidle")
        except:
            self.use_xidle = True
    
    def PluginPreferences(self,parent):
        def toggled(widget):
            if widget.get_active():
                config.set("plugins", "imms_use_xidle", "true")
                self.use_xidle = True
            else:
                config.set("plugins", "imms_use_xidle", "false")
                self.use_xidle = False
            if self.connected:
                self.write_command("Setup " + str(self.use_xidle))
        xidle = gtk.CheckButton(_("Use X idleness statistics."))
        xidle.set_active(self.use_xidle)
        xidle.connect("toggled", toggled)
        return xidle

    def enabled(self):
        log("enabled\n")
        order = widgets.main.order
        self.order_id = order.connect_after("changed",self.order_changed)
        model = widgets.main.playlist.pl
        self.songs_id = model.connect_after("songs-set",self.active_songlist_changed)

        proxy = PlayListModelProxy(model,self)
        widgets.main.playlist.pl = proxy
        self.modelproxy = proxy
        self._prepare_songlist()
        self.active_songlist_changed(proxy)
        self.enable = True
        os.system("nice -n 5 immsd &")
        gobject.timeout_add(3000,self.enabled_continue)
    
    def enabled_continue(self):
        self.connect()
        self.order_changed(widgets.main.order)

    def disabled(self):
        log("disabled")
        widgets.main.order.disconnect(self.order_id)
        self.order_id = None
        model = widgets.main.playlist.pl._subject
        model.disconnect(self.songs_id)
        self.songs_id = None
        widgets.main.playlist.pl = model
        self.modelproxy = None
        self.enable = False
        
    def destroy(self):
        self.disabled()
        
    def order_changed(self,playorder):
        if playorder.get_active_name() == "weighted":
            self.activated = True
            if (self.songlist_sent):
                self.queue_song()
            log("Activating")
        else:
            self.activated = False
            self.immsqueue = []
            log("Deactivating")
 
    def connect(self):
        try:
            sock = socket.socket(socket.AF_UNIX,socket.SOCK_STREAM)
            sock.connect(self.get_imms_root("socket"))
            sock.send("IMMS\n")
            log(self.__buffer)
            sock.send(self.__buffer)
            self.__buffer = ""
        except os.error, msg:
            log("Connection failed." + msg)
            return
        log ("Connection Established.")
        self.socket = sock
        self.connected = True
        self.thread = threading.Thread(None,self.socket_handler)
        self.thread.setDaemon(True)
        self.thread.start()
           
    def get_imms_root(self, filename):
        try:
            return os.environ['IMMSROOT'] + "/" + filename
        except:
            return os.environ['HOME'] + "/.imms/" + filename
     
    def write_command(self,command,log_this = True):
        if not self.connected:
            self.__buffer += command + "\n"
        else:
            command = self.__buffer + command
            self.__buffer = ""
            try:
                sent = self.socket.send(command + "\n")
                if log_this:
                    log("sent: " + command)
            except socket.error, msg:
                log(msg)
                self.__buffer += command + "\n"
        
    def queue_song(self):
        if not len(self.immsqueue) and not self.sent_queuerequest:
            self.write_command("SelectNext")
            self.sent_queuerequest = True
        
    def get_next(self):
        if self.activated:
            self.queue_song()
            if len(self.immsqueue):
                return self.immsqueue.pop(0)
        return False
    
    def send_active_songlist(self):
        self.immsqueue = []
        length = str(len(self.active_songlist()))
        self.write_command("PlaylistChanged " + length)

    def socket_handler(self):
        log("socket_handler()")
        try:
            self.write_command("Setup " + str(self.use_xidle))
            while self.enable:
                select.select( (self.socket,), (), () )
                for line in self.readlines():
                    self.process_line(line)
        except socket.error, msg:
            log("Connection terminated: " + msg)
        log("socket_handler exiting...")
        self.connected = False
        self.socket = None
            
    def readlines(self):
        try:
            buf = self.__leftover + self.socket.recv(4096)
            self.__leftover = ""
        except:
            return None
        lines = buf.splitlines()
        if buf[len(buf)-1] != '\n':
            self.__leftover = lines.pop()
        return lines
    
    def send_song(self,index):
        try:
            filename = self.songlist()[index]['~filename']
            index = str(index)
        except:
            log("Invalid index. " + str(index))
            return
        self.write_command("PlaylistItem " + index + " " + filename, False)
        
    def send_playlist(self):
        for song in self.active_songlist():
            index = str(self.song_to_index(song))
            filename = song['~filename']
            self.write_command("Playlist " + index + " " + filename, False)
        self.write_command("PlaylistEnd");
        if (not self.songlist_sent):
            self.songlist_sent = True
            self.order_changed(widgets.main.order)
    
    def process_line(self,line):
        parts = line.split()
        command = parts.pop(0)
        if command == "ResetSelection":
            log("Receiving: " + line.strip())
            self.immsqueue = []
            self.queue_song()
        elif command == "TryAgain":
            self.write_command("SelectNext")
        elif command == "EnqueueNext":
            next = int(parts[0])
            song = self.songlist()[next]
            self.immsqueue.append(song)
            self.sent_queuerequest = False
            log("Queueing " + str(next) + " " + song['~filename'])
        elif command == "PlaylistChanged":
            log("Receiving: " + line.strip())
            self.send_active_songlist()
        elif command == "GetEntirePlaylist":
            log("Receiving: " + line.strip())
            self.send_playlist()
        elif command == "GetPlaylistItem":
            self.send_song(int(parts[0]))
        else:
            log("IMMS: unknown command " + line)
 
    __leftover = ""
    __lines = []
    def plugin_on_song_ended(self, song, skipped):
        log("plugin_on_song_ended: " + str(skipped))
        if song is None: return
        playpos = player.playlist.get_position() / 1000.0
        length = song['~#length']
        end = str((length - playpos) < 20.0)
        forced = str(self.song_manual)
        bad = str(length < 30.0)
        self.write_command("EndSong " + end + " " + forced + " " + bad)

    def plugin_on_song_started(self, song):
        log("plugin_on_song_started")
        if song is None: return
        index = self.song_to_index(song)
        filename = song['~filename']
        if index:
            self.write_command("StartSong " + str(index) + " " + filename)
    
# this event might be necessary to track renames.
    def plugin_on_changed(self,songlist):
        log("plugin_on_changed")

# need to update songlist when this gets fired
    def plugin_on_added(self,songlist):
        log("plugin_on_added")
        for song in songlist:
            self.songdic[song.key] = len(self.songs)
            self.songs.extend(song)
        
# just clearing out the song object to keep indexes stable
    def plugin_on_removed(self,songlist):
        log("plugin_on_removed")
        for song in songlist:
            index = self.song_to_index(song)
            self.songs[index] = None

# I guess pauses aren't useful.
    def plugin_on_paused(self):
        log("plugin_on_paused")
    
    def plugin_on_unpaused(self):
        log("plugin_on_unpaused")
        
    def plugin_on_seek(self, song, msec):
        log("plugin_on_seek: " + str(msec))
    
    def song_to_index(self, song):
        return self.songdic[song.key]
            
    def songlist(self):
        return self.songs

    def active_songlist_changed(self,model = None):
        songs = self.modelproxy.get()
        self.set_active_songlist(songs)

    def set_active_songlist(self,songs):
        self.active_songs = songs
        self.songlist_sent = False
        self.send_active_songlist()
        
    def active_songlist(self):
        return self.active_songs
    
    def _prepare_songlist(self):
        self.songs = library.query("")
        for index,song in enumerate(self.songs):
            self.songdic[song.key] = index


class Proxy:
    def __init__( self, subject ):
        self._subject = subject
    def __getattr__( self, name ):
        return getattr( self._subject, name )

class PlayListModelProxy(Proxy):
    __imms = None
    _subject = None
    def __init__(self,subject,imms):
        self._subject = subject
        self.__imms = imms
        
    def next(self):
        self.__imms.song_manual = False
        next = self.__imms.get_next()
        if next: 
            self._subject.go_to(next)
        else:
            self._subject.next()

    def next_ended(self):
        self.next()
    
    def go_to(self,song):
        self.__imms.song_manual = True
        self._subject.go_to(song)