← Back to branch summary

~cahr-gr/covergloobus/ui

« back to all changes in this revision

Viewing changes to src/players/Listen.py

  • Committer: Alexandr Grigorcea
  • Date: 2010-10-17 10:18:21 UTC
  • Revision ID: cahr.gr@gmail.com-20101017101821-9y1dz81ijj25fraf
fixed all players, added CliPlayer interface with moc and deadbeef using it

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/players/Listen.py
14
14
 
15
15
import dbus
16
16
import gobject
 
17
 
 
18
from common import _
 
19
from common import c
 
20
from common import State
 
21
from common import Track
 
22
from common import TRACK, STATE
17
23
from GenericPlayer import GenericPlayer
18
 
from common import Track
19
 
from common import c
20
 
from common import _
21
24
 
22
25
class ListenPlayer(GenericPlayer):
23
26
    __name__ = 'Listen'
28
31
    DBUS_NAME   = 'org.gnome.Listen'
29
32
    DBUS_OBJECT = '/org/gnome/listen'
30
33
 
31
 
    dbus_object = None
32
 
    timeout_id = None
 
34
    capabilities = ('time',)
 
35
 
 
36
    iface = None
 
37
 
 
38
    _data = {}
 
39
    _state = State.CLOSED
 
40
    _timeout_id = None
 
41
    _track = Track()
33
42
 
34
43
    def connect(self):                        #Connect with dbus
35
 
        self.session_bus = dbus.SessionBus()
36
 
        self.dbus_object = self.session_bus.get_object(self.DBUS_NAME, self.DBUS_OBJECT)
37
 
        self.timeout_id = gobject.timeout_add(2000, self.check_new_song)
 
44
        session_bus = dbus.SessionBus()
 
45
        self.iface = session_bus.get_object(self.DBUS_NAME, self.DBUS_OBJECT)
 
46
        self._timeout_id = gobject.timeout_add(2000, self.check_new_song)
38
47
        return True
39
48
 
40
49
    def disconnect(self):
41
 
        if self.timeout_id:
42
 
            gobject.source_remove(self.timeout_id)
 
50
        if self._timeout_id:
 
51
            gobject.source_remove(self._timeout_id)
43
52
 
44
53
    def check_new_song(self):
45
 
        self.state_handler(track=True)
 
54
        state = self.get_state()
 
55
        if state != self._state:
 
56
            self._state = state
 
57
            self.cg.update(STATE, state)
 
58
        if state == State.PLAYING:
 
59
            data = {
 
60
                'title' : self.iface.get_title(),
 
61
                'album' : self.iface.get_album(),
 
62
                'artist' : self.iface.get_artist(),
 
63
                'cover' : self.iface.get_cover_path(),
 
64
                'location' : self.iface.get_uri(),
 
65
                'length' : self.iface.current_song_length()
 
66
            }
 
67
            if data != self._data:
 
68
                self._data = data
 
69
                self._track = Track(**data)
 
70
                self.cg.update(TRACK, self._track)
46
71
        return True
47
72
 
48
 
    def get_title(self):
49
 
        try:
50
 
            title = self.dbus_object.get_title()
51
 
            if title:
52
 
                return title
53
 
        except:
54
 
            pass
55
 
        return ""
56
 
 
57
 
    def get_album(self):
58
 
        try:
59
 
            album = self.dbus_object.get_album()
60
 
            if album:
61
 
                return album
62
 
        except:
63
 
            pass
64
 
        return ""
65
 
 
66
 
    def get_artist(self):
67
 
        try:
68
 
            artist = self.dbus_object.get_artist()
69
 
            if artist:
70
 
                return artist
71
 
        except:
72
 
            pass
73
 
        return ""
74
 
 
75
 
    def get_cover_path(self,data=None):
76
 
        try:
77
 
            return self.dbus_object.get_cover_path()
78
 
        except:
79
 
            return ''
80
 
 
81
73
    def get_state(self):
82
74
        """
83
75
            Returns players actual state.
84
76
            @return: string - playing, paused, stopped
85
77
        """
86
 
        if self.dbus_object.playing():
87
 
            return 'playing'
 
78
        if self.iface.playing():
 
79
            return State.PLAYING
88
80
        else:
89
 
            return 'paused'
90
 
 
91
 
    def is_playing(self):
92
 
        try:
93
 
            return self.dbus_object.playing()
94
 
        except:
95
 
            return False
96
 
 
97
 
    def previous(self, widget, event):
98
 
        if self.active:
99
 
            self.dbus_object.previous()
100
 
 
101
 
    def play(self, widget, event):
102
 
        if self.active:
103
 
            self.dbus_object.play_pause()
104
 
 
105
 
    def next(self, widget, event):
106
 
        if self.active:
107
 
            self.dbus_object.next()
 
81
            return State.PAUSED
108
82
 
109
83
    def get_track(self):
110
 
        data = {
111
 
            'title' : self.get_title(),
112
 
            'artist': self.get_artist(),
113
 
            'album' : self.get_album()
114
 
        }
115
 
        cover = self.get_cover_path(data)
116
 
        track = Track(
117
 
            title = data['title'],
118
 
            album = data['album'],
119
 
            artist= data['artist'],
120
 
            cover = cover
121
 
        )
122
 
        return track
123
 
 
 
84
        return self._track
 
85
 
 
86
    def get_position(self):
 
87
        return self.iface.current_position()
 
88
 
 
89
    def previous(self):
 
90
        self.dbus_object.previous()
 
91
 
 
92
    def play(self):
 
93
        self.iface.play_pause()
 
94
 
 
95
    def next(self):
 
96
        self.dbus_object.next()