Attachment #171192 for bug #246168

View | Details | Raw Unified | Return to bug 246168
Collapse All | Expand All




from coherence.upnp.core.soap_service import errorCode
from coherence.upnp.core import DIDLLite

import coherence.extern.louie as louie

from coherence.extern.simple_plugin import Plugin


    logCategory = 'rb_media_renderer'

    implements = ['MediaRenderer']
    vendor_value_defaults = {'RenderingControl': {'A_ARG_TYPE_Channel':'Master'},
                             'AVTransport': {'A_ARG_TYPE_SeekMode':('ABS_TIME','REL_TIME')}}
    vendor_range_defaults = {'RenderingControl': {'Volume': {'maximum':100}}}

    def __init__(self, device, **kwargs):


        self.player = None
        self.metadata = None
        self.host = '127.0.0.1'
        self.name = "Rhythmbox on %s" % self.server.coherence.hostname

        self.player = self.shell.get_player()
        self.player.connect ('playing-song-changed',
                                 self.playing_song_changed),
        self.player.connect ('playing-changed',
                                 self.playing_changed)
        self.player.connect ('elapsed-changed',
                                 self.elapsed_changed)
        self.player.connect("notify::volume", self.volume_changed)
        louie.send('Coherence.UPnP.Backend.init_completed', None, backend=self)

        self.playing = False

        self.metadata = metadata
        self.tags = {}

        was_playing = self.playing

        if was_playing == True:
            self.stop()

        if len(metadata)>0:
            elt = DIDLLite.DIDLElement.fromString(metadata)
            if elt.numItems() == 1:
                item = elt.getItems()[0]

                if uri.startswith('track-'):
                    self.entry = self.shell.props.db.entry_lookup_by_id(int(uri[6:]))
                else:
                    self.entry = self.shell.props.db.entry_lookup_by_location(uri)
                self.warning("check for entry %r %r %r", self.entry,item.server_uuid,uri)
                if self.entry == None:
                    if item.server_uuid is not None:
                        entry_type = self.shell.props.db.entry_register_type("CoherenceUpnp:" + item.server_uuid)
                        self.entry = self.shell.props.db.entry_new(entry_type, uri)
                        self.warning("create new entry %r", self.entry)
                    else:
                        entry_type = self.shell.props.db.entry_register_type("CoherencePlayer")
                        self.entry = self.shell.props.db.entry_new(entry_type, uri)
                        self.warning("load and check for entry %r", self.entry)


                duration = None
                size = None
                bitrate = None

                    self.shell.props.db.set(self.entry, rhythmdb.PROP_FILE_SIZE,int(size))

        else:
            if uri.startswith('track-'):
                self.entry = self.shell.props.db.entry_lookup_by_id(int(uri[6:]))
            else:
                #self.shell.load_uri(uri,play=False)
                #self.entry = self.shell.props.db.entry_lookup_by_location(uri)
                entry_type = self.shell.props.db.entry_register_type("CoherencePlayer")
                self.entry = self.shell.props.db.entry_new(entry_type, uri)


        self.playing = False
        self.metadata = metadata

        connection_id = self.server.connection_manager_server.lookup_avt_id(self.current_connection_id)
        self.server.av_transport_server.set_variable(connection_id, 'CurrentTransportActions','Play,Stop,Pause,Seek')
        self.server.av_transport_server.set_variable(connection_id, 'NumberOfTracks',1)
        self.server.av_transport_server.set_variable(connection_id, 'CurrentTrackURI',uri)
        self.server.av_transport_server.set_variable(connection_id, 'AVTransportURI',uri)

        self.server.av_transport_server.set_variable(connection_id, 'CurrentTrackURI',uri)
        self.server.av_transport_server.set_variable(connection_id, 'CurrentTrackMetaData',metadata)

        if was_playing == True:
            self.play()

    def start(self, uri):
        self.load(uri)
        self.play()

        #    self.server.connection_manager_server.lookup_avt_id(self.current_connection_id),\
        #                     'TransportState', 'PAUSED_PLAYBACK')

    def seek(self, location, old_state):
        """
        @param location:    simple number = time to seek to, in seconds
                            +nL = relative seek forward n seconds
                            -nL = relative seek backwards n seconds
        """
        self.warning("player seek %r", location)
        self.player.seek(location)
        self.server.av_transport_server.set_variable(0, 'TransportState', old_state)

    def mute(self):
        self.muted_volume = self.volume

        self.player.set_volume(float(volume/100.0))

    def upnp_init(self):
        self.player.connect ('playing-song-changed',
                                 self.playing_song_changed),
        self.player.connect ('playing-changed',
                                 self.playing_changed)
        self.player.connect ('elapsed-changed',
                                 self.elapsed_changed)
        self.player.connect("notify::volume", self.volume_changed)

        self.current_connection_id = None
        self.server.connection_manager_server.set_variable(0, 'SinkProtocolInfo',
                            ['rhythmbox:%s:audio/mpeg:*' % self.server.coherence.hostname,
                             'http-get:*:audio/mpeg:*'],
                            default=True)
        self.server.av_transport_server.set_variable(0, 'TransportState', 'NO_MEDIA_PRESENT', default=True)

        self.stop()
        return {}

    def upnp_Seek(self, *args, **kwargs):
        InstanceID = int(kwargs['InstanceID'])
        Unit = kwargs['Unit']
        Target = kwargs['Target']
        if Unit in ['ABS_TIME','REL_TIME']:
            old_state = self.server.av_transport_server.get_variable(0, 'TransportState')
            self.server.av_transport_server.set_variable(0, 'TransportState', 'TRANSITIONING')
            h,m,s = Target.split(':')
            seconds = int(h)*3600 + int(m)*60 + int(s)
            self.seek(seconds, old_state)
        return {}

    def upnp_SetAVTransportURI(self, *args, **kwargs):
        InstanceID = int(kwargs['InstanceID'])
        CurrentURI = kwargs['CurrentURI']

        #print '>>>', local_protocol_infos
        if len(CurrentURIMetaData)==0:
            self.load(CurrentURI,CurrentURIMetaData)
            return {}
        else:
            elt = DIDLLite.DIDLElement.fromString(CurrentURIMetaData)
            #import pdb; pdb.set_trace()
            if elt.numItems() == 1:
                item = elt.getItems()[0]
                res = item.res.get_matching(local_protocol_infos, protocol_type='rhythmbox')
                if len(res) == 0:
                    res = item.res.get_matching(local_protocol_infos)
                if len(res) > 0:




# Copyright 2007, Frank Scholz <coherence@beebits.net>

import rhythmdb
import coherence.extern.louie as louie
import urllib
from coherence.upnp.core import DIDLLite

from coherence.backend import BackendItem, BackendStore

ROOT_CONTAINER_ID = 0
AUDIO_CONTAINER = 100
AUDIO_ALL_CONTAINER_ID = 101
AUDIO_ARTIST_CONTAINER_ID = 102
AUDIO_ALBUM_CONTAINER_ID = 103

CONTAINER_COUNT = 10000



# most of this class is from Coherence, originally under the MIT licence

class Container(BackendItem):

    logCategory = 'rb_media_store'



    def get_children(self,start=0,request_count=0):
        if callable(self.children):
            children = self.children(self.id)
        else:
            children = self.children


            return children[start:request_count]

    def get_child_count(self):
        return len(self.get_children())

    def get_item(self, parent_id=None):
            return len(self.children())
        else:
            return len(self.children)

    def get_item(self):
        self.item.childCount = self.get_child_count()
        return self.item


        return self.id


class Album(BackendItem):

    logCategory = 'rb_media_store'

    def __init__(self, store, title, id, parent_id):
        self.id = id
        self.title = title
        self.store = store

        def collate (model, path, iter):
            self.info("Album get_children %r %r %r" %(model, path, iter))
            id = model.get(iter, 0)[0]
            children.append(Track(self.store,id,self.id))

        self.tracks_per_album_query.foreach(collate)


    def get_child_count(self):
        return len(self.get_children())

    def get_item(self, parent_id = AUDIO_ALBUM_CONTAINER_ID):
        item = DIDLLite.MusicAlbum(self.id, parent_id, self.title)
        return item

    def get_id(self):

        return self.cover


class Artist(BackendItem):

    logCategory = 'rb_media_store'

    def __init__(self, store, name, id, parent_id):
        self.id = id
        self.name = name
        self.store = store

    def get_child_count(self):
        return len(self.get_children())

    def get_item(self, parent_id = AUDIO_ARTIST_CONTAINER_ID):
        item = DIDLLite.MusicArtist(self.id, parent_id, self.name)
        return item

    def get_id(self):

        return self.name


class Track(BackendItem):

    logCategory = 'rb_media_store'

    def __init__(self, store, id, parent_id):
        self.store = store
        if type(id) == int:
            self.id = id
        else:
            self.id = self.store.db.entry_get (id, rhythmdb.PROP_ENTRY_ID)
        self.parent_id = parent_id

    def get_children(self, start=0, request_count=0):
        return []

    def get_child_count(self):
        return 0

    def get_item(self, parent_id=None):

        self.info("Track get_item %r @ %r" %(self.id,self.parent_id))

        host = ""


            mimetype = "audio/mpeg"
        size = self.store.db.entry_get(entry, rhythmdb.PROP_FILE_SIZE)

        album = self.store.db.entry_get(entry, rhythmdb.PROP_ALBUM)
        if self.parent_id == None:
            try:
                self.parent_id = self.store.albums[album].id
            except:
                pass

        # create item
        item = DIDLLite.MusicTrack(self.id + TRACK_COUNT,self.parent_id)
        item.album = album

        item.artist = self.store.db.entry_get(entry, rhythmdb.PROP_ARTIST)
        #item.date =
        item.genre = self.store.db.entry_get(entry, rhythmdb.PROP_GENRE)

        #self.warning("cover for %r is %r", item.title, cover)
        #item.albumArtURI = ## can we somehow store art in the upnp share??

        # add internal resource
        #res = DIDLLite.Resource(location, 'internal:%s:%s:*' % (host, mimetype))
        #res.size = size
        #res.duration = duration
        #res.bitrate = bitrate
        #item.res.append(res)

        # add http resource
        res = DIDLLite.Resource(self.get_url(), 'http-get:*:%s:*' % mimetype)
        if size > 0:

            res.bitrate = str(bitrate)
        item.res.append(res)

        # add internal resource
        res = DIDLLite.Resource('track-%d' % self.id, 'rhythmbox:%s:%s:*' % (self.store.server.coherence.hostname, mimetype))
        if size > 0:
            res.size = size
        if duration > 0:
            res.duration = str(duration)
        if bitrate > 0:
            res.bitrate = str(bitrate)
        item.res.append(res)

        return item

    def get_id(self):


        return location

class MediaStore(BackendStore):

    logCategory = 'rb_media_store'
    implements = ['MediaServer']

    def __init__(self, server, **kwargs):
        self.warning("__init__ MediaStore %r", kwargs)
        self.server = server
        self.db = kwargs['db']
        self.plugin = kwargs['plugin']

        self.wmc_mapping.update({'4': lambda : self.get_by_id(AUDIO_ALL_CONTAINER_ID),    # all tracks
                                 '7': lambda : self.get_by_id(AUDIO_ALBUM_CONTAINER_ID),    # all albums
                                 '6': lambda : self.get_by_id(AUDIO_ARTIST_CONTAINER_ID),    # all artists
                                })

        self.update_id = 0

        self.next_id = CONTAINER_COUNT

    def get_by_id(self,id):

        self.info("looking for id %r", id)
        id = id.split('@',1)
        item_id = id[0]
        item_id = int(item_id)
        if item_id < TRACK_COUNT:
            try:
                item = self.containers[item_id]
            except KeyError:
                item = None
        else:
            item = Track(self, (item_id - TRACK_COUNT),None)

        return item


    def upnp_init(self):
        if self.server:
            self.server.connection_manager_server.set_variable(0, 'SourceProtocolInfo', [
                'rhythmbox:%s:*:*' % self.server.coherence.hostname,
                'http-get:*:audio/mpeg:*',
            ])
        self.warning("__init__ MediaStore initialized")


    def children_tracks(self, parent_id):
        tracks = []

        def track_cb (entry):
            if self.db.entry_get (entry, rhythmdb.PROP_HIDDEN):
                return
            id = self.db.entry_get (entry, rhythmdb.PROP_ENTRY_ID)
            track = Track(self, id, parent_id)
            tracks.append(track)

        self.db.entry_foreach_by_type (self.db.entry_type_get_by_name('song'), track_cb)
        return tracks

    def children_albums(self,parent_id):
        albums =  {}

        self.info('children_albums')

            self.info("children_albums collate %r %r", name, priority)
            if priority is False:
                id = self.get_next_container_id()
                album = Album(self, name, id,parent_id)
                self.containers[id] = album
                albums[name] = album


        albums.sort(cmp=album_sort)
        return albums

    def children_artists(self,parent_id):
        artists = []

        self.info('children_artists')

            priority = model.get(iter, 1)[0]
            if priority is False:
                id = self.get_next_container_id()
                artist = Artist(self,name, id,parent_id)
                self.containers[id] = artist
                artists.append(artist)





# http://opensource.org/licenses/mit-license.php
#
# Copyright 2007, James Livingston  <doclivingston@gmail.com>
# Copyright 2007,2008 Frank Scholz <coherence@beebits.net>

import rb, rhythmdb
import gobject, gtk

from coherence import __version_info__ as coherence_version

from coherence import log
from coherence.upnp.core import DIDLLite

class UpnpSource(rb.BrowserSource,log.Loggable):


    __gproperties__ = {
        'plugin': (rb.Plugin, 'plugin', 'plugin', gobject.PARAM_WRITABLE|gobject.PARAM_CONSTRUCT_ONLY),
        'client': (gobject.TYPE_PYOBJECT, 'client', 'client', gobject.PARAM_WRITABLE|gobject.PARAM_CONSTRUCT_ONLY),
        'udn': (gobject.TYPE_PYOBJECT, 'udn', 'udn', gobject.PARAM_WRITABLE|gobject.PARAM_CONSTRUCT_ONLY),
    }

    def __init__(self):

        elif property.name == 'client':
            self.__client = value
            self.props.name = self.__client.device.get_friendly_name()
        elif property.name == 'udn':
            self.__udn = value
        else:
            raise AttributeError, 'unknown property %s' % property.name




    def load_db(self, id):
        d = self.__client.content_directory.browse(id, browse_flag='BrowseDirectChildren', process_result=False, backward_compatibility=False)
        d.addCallback(self.process_media_server_browse, self.__udn)
        else:
            d = self.__client.content_directory.browse(id, browse_flag='BrowseDirectChildren', process_result=False, backward_compatibility=False)
        d.addCallback(self.process_media_server_browse, self.__usn)


    def state_variable_change(self, variable, udn=None):
        self.info("%s changed from >%s< to >%s<", variable.name, variable.old_value, variable.value)
        if variable.old_value == '':
            return


                container = changes.pop(0).strip()
                update_id = changes.pop(0).strip()
                if container in self.container_watch:
                    self.info("we have a change in %r, container needs a reload", container)
                    self.load_db(container)


    def new_process_media_server_browse(self, results, udn):
        didl = DIDLLite.DIDLElement.fromString(results['Result'])
        for item in didl.getItems():
            self.info("process_media_server_browse %r %r", item.id, item)
            if item.upnp_class.startswith('object.container'):
                self.load_db(item.id)


                    self.__db.commit()


    def old_process_media_server_browse(self, results, usn):
        for k,v in results.iteritems():
            if k == 'items':
                for id, values in v.iteritems():
                    if values['upnp_class'].startswith('object.container'):
                        self.load_db(id)
                    if values['upnp_class'].startswith('object.item.audioItem'):
                        # (url, [method, something which is in asterix,  format, semicolon delimited key=value map of something])
                        resources = [(k, v.split(':')) for (k, v) in values['resources'].iteritems()]
                        # break data into map
                        for r in resources:
                            if r[1][3] is not '*':
                                r[1][3] = dict([v.split('=') for v in r[1][3].split(';')])
                            else:
                                r[1][3] = dict()

                        url = None
                        for r in resources:
                            if r[1][3].has_key('DLNA.ORG_CI') and r[1][3]['DLNA.ORG_CI'] is not '1':
                                url = r[0]
                                break

                        if url is None:
                            # use transcoded format, since we can't find a normal one
                            url = resources[0][0]

                        entry = self.__db.entry_lookup_by_location (url)
                        if entry == None:
                            entry = self.__db.entry_new(self.__entry_type, url)

                        self.__db.set(entry, rhythmdb.PROP_TITLE, values['title'])

                        self.__db.commit()

gobject.type_register(UpnpSource)

Return to bug 246168

Lines 10-16 Link Here

(-)plugins-old/coherence/upnp_coherence/MediaPlayer.py (-23 / +57 lines)
10	from coherence.upnp.core.soap_service import errorCode	10	from coherence.upnp.core.soap_service import errorCode
11	from coherence.upnp.core import DIDLLite	11	from coherence.upnp.core import DIDLLite
12		12
13	import louie	13	import coherence.extern.louie as louie
14		14
15	from coherence.extern.simple_plugin import Plugin	15	from coherence.extern.simple_plugin import Plugin
16		16
Lines 26-32 Link Here
26	logCategory = 'rb_media_renderer'	26	logCategory = 'rb_media_renderer'
27		27
28	implements = ['MediaRenderer']	28	implements = ['MediaRenderer']
29	vendor_value_defaults = {'RenderingControl': {'A_ARG_TYPE_Channel':'Master'}}	29	vendor_value_defaults = {'RenderingControl': {'A_ARG_TYPE_Channel':'Master'},
		30	'AVTransport': {'A_ARG_TYPE_SeekMode':('ABS_TIME','REL_TIME')}}
30	vendor_range_defaults = {'RenderingControl': {'Volume': {'maximum':100}}}	31	vendor_range_defaults = {'RenderingControl': {'Volume': {'maximum':100}}}
31		32
32	def __init__(self, device, **kwargs):	33	def __init__(self, device, **kwargs):
Lines 36-52 Link Here
36		37
37	self.player = None	38	self.player = None
38	self.metadata = None	39	self.metadata = None
39	self.host = '127.0.0.1'
40	self.name = "Rhythmbox on %s" % self.server.coherence.hostname	40	self.name = "Rhythmbox on %s" % self.server.coherence.hostname
41		41
42	self.player = self.shell.get_player()	42	self.player = self.shell.get_player()
43	self.player.connect ('playing-song-changed',
44	self.playing_song_changed),
45	self.player.connect ('playing-changed',
46	self.playing_changed)
47	self.player.connect ('elapsed-changed',
48	self.elapsed_changed)
49	self.player.connect("notify::volume", self.volume_changed)
50	louie.send('Coherence.UPnP.Backend.init_completed', None, backend=self)	43	louie.send('Coherence.UPnP.Backend.init_completed', None, backend=self)
51		44
52	self.playing = False	45	self.playing = False
Lines 226-249 Link Here
226	self.metadata = metadata	219	self.metadata = metadata
227	self.tags = {}	220	self.tags = {}
228		221
229	if len(self.metadata)>0:	222	was_playing = self.playing
230	elt = DIDLLite.DIDLElement.fromString(self.metadata)	223
		224	if was_playing == True:
		225	self.stop()
		226
		227	if len(metadata)>0:
		228	elt = DIDLLite.DIDLElement.fromString(metadata)
231	if elt.numItems() == 1:	229	if elt.numItems() == 1:
232	item = elt.getItems()[0]	230	item = elt.getItems()[0]
233		231
234	self.entry = self.shell.props.db.entry_lookup_by_location(uri)	232	if uri.startswith('track-'):
235	self.warning("check for entry %r %r", self.entry, item.server_uuid)	233	self.entry = self.shell.props.db.entry_lookup_by_id(int(uri[6:]))
		234	else:
		235	self.entry = self.shell.props.db.entry_lookup_by_location(uri)
		236	self.warning("check for entry %r %r %r", self.entry,item.server_uuid,uri)
236	if self.entry == None:	237	if self.entry == None:
237	if item.server_uuid is not None:	238	if item.server_uuid is not None:
238	entry_type = self.shell.props.db.entry_register_type("CoherenceUpnp:" + item.server_uuid)	239	entry_type = self.shell.props.db.entry_register_type("CoherenceUpnp:" + item.server_uuid)
239	self.entry = self.shell.props.db.entry_new(entry_type, uri)	240	self.entry = self.shell.props.db.entry_new(entry_type, uri)
240	self.warning("create new entry %r", self.entry)	241	self.warning("create new entry %r", self.entry)
241	else:	242	else:
242	self.shell.load_uri(uri,play=False)	243	entry_type = self.shell.props.db.entry_register_type("CoherencePlayer")
243	self.entry = self.shell.props.db.entry_lookup_by_location(uri)	244	self.entry = self.shell.props.db.entry_new(entry_type, uri)
244	self.warning("load and check for entry %r", self.entry)	245	self.warning("load and check for entry %r", self.entry)
245		246
246
247	duration = None	247	duration = None
248	size = None	248	size = None
249	bitrate = None	249	bitrate = None
Lines 283-295 Link Here
283	self.shell.props.db.set(self.entry, rhythmdb.PROP_FILE_SIZE,int(size))	283	self.shell.props.db.set(self.entry, rhythmdb.PROP_FILE_SIZE,int(size))
284		284
285	else:	285	else:
286	self.shell.load_uri(uri,play=False)	286	if uri.startswith('track-'):
287	self.entry = self.shell.props.db.entry_lookup_by_location(uri)	287	self.entry = self.shell.props.db.entry_lookup_by_id(int(uri[6:]))
		288	else:
		289	#self.shell.load_uri(uri,play=False)
		290	#self.entry = self.shell.props.db.entry_lookup_by_location(uri)
		291	entry_type = self.shell.props.db.entry_register_type("CoherencePlayer")
		292	self.entry = self.shell.props.db.entry_new(entry_type, uri)
		293
288		294
289	self.playing = False	295	self.playing = False
		296	self.metadata = metadata
290		297
291	connection_id = self.server.connection_manager_server.lookup_avt_id(self.current_connection_id)	298	connection_id = self.server.connection_manager_server.lookup_avt_id(self.current_connection_id)
292	self.server.av_transport_server.set_variable(connection_id, 'CurrentTransportActions','Play,Stop,Pause')	299	self.server.av_transport_server.set_variable(connection_id, 'CurrentTransportActions','Play,Stop,Pause,Seek')
293	self.server.av_transport_server.set_variable(connection_id, 'NumberOfTracks',1)	300	self.server.av_transport_server.set_variable(connection_id, 'NumberOfTracks',1)
294	self.server.av_transport_server.set_variable(connection_id, 'CurrentTrackURI',uri)	301	self.server.av_transport_server.set_variable(connection_id, 'CurrentTrackURI',uri)
295	self.server.av_transport_server.set_variable(connection_id, 'AVTransportURI',uri)	302	self.server.av_transport_server.set_variable(connection_id, 'AVTransportURI',uri)
Lines 297-302 Link Here
297	self.server.av_transport_server.set_variable(connection_id, 'CurrentTrackURI',uri)	304	self.server.av_transport_server.set_variable(connection_id, 'CurrentTrackURI',uri)
298	self.server.av_transport_server.set_variable(connection_id, 'CurrentTrackMetaData',metadata)	305	self.server.av_transport_server.set_variable(connection_id, 'CurrentTrackMetaData',metadata)
299		306
		307	if was_playing == True:
		308	self.play()
		309
300	def start(self, uri):	310	def start(self, uri):
301	self.load(uri)	311	self.load(uri)
302	self.play()	312	self.play()
Lines 328-339 Link Here
328	# self.server.connection_manager_server.lookup_avt_id(self.current_connection_id),\	338	# self.server.connection_manager_server.lookup_avt_id(self.current_connection_id),\
329	# 'TransportState', 'PAUSED_PLAYBACK')	339	# 'TransportState', 'PAUSED_PLAYBACK')
330		340
331	def seek(self, location):	341	def seek(self, location, old_state):
332	"""	342	"""
333	@param location: simple number = time to seek to, in seconds	343	@param location: simple number = time to seek to, in seconds
334	+nL = relative seek forward n seconds	344	+nL = relative seek forward n seconds
335	-nL = relative seek backwards n seconds	345	-nL = relative seek backwards n seconds
336	"""	346	"""
		347	self.warning("player seek %r", location)
		348	self.player.seek(location)
		349	self.server.av_transport_server.set_variable(0, 'TransportState', old_state)
337		350
338	def mute(self):	351	def mute(self):
339	self.muted_volume = self.volume	352	self.muted_volume = self.volume
Lines 368-376 Link Here
368	self.player.set_volume(float(volume/100.0))	381	self.player.set_volume(float(volume/100.0))
369		382
370	def upnp_init(self):	383	def upnp_init(self):
		384	self.player.connect ('playing-song-changed',
		385	self.playing_song_changed),
		386	self.player.connect ('playing-changed',
		387	self.playing_changed)
		388	self.player.connect ('elapsed-changed',
		389	self.elapsed_changed)
		390	self.player.connect("notify::volume", self.volume_changed)
		391
371	self.current_connection_id = None	392	self.current_connection_id = None
372	self.server.connection_manager_server.set_variable(0, 'SinkProtocolInfo',	393	self.server.connection_manager_server.set_variable(0, 'SinkProtocolInfo',
373	['internal:%s::' % self.host,	394	['rhythmbox:%s:audio/mpeg:*' % self.server.coherence.hostname,
374	'http-get::audio/mpeg:'],	395	'http-get::audio/mpeg:'],
375	default=True)	396	default=True)
376	self.server.av_transport_server.set_variable(0, 'TransportState', 'NO_MEDIA_PRESENT', default=True)	397	self.server.av_transport_server.set_variable(0, 'TransportState', 'NO_MEDIA_PRESENT', default=True)
Lines 396-401 Link Here
396	self.stop()	417	self.stop()
397	return {}	418	return {}
398		419
		420	def upnp_Seek(self, args, *kwargs):
		421	InstanceID = int(kwargs['InstanceID'])
		422	Unit = kwargs['Unit']
		423	Target = kwargs['Target']
		424	if Unit in ['ABS_TIME','REL_TIME']:
		425	old_state = self.server.av_transport_server.get_variable(0, 'TransportState')
		426	self.server.av_transport_server.set_variable(0, 'TransportState', 'TRANSITIONING')
		427	h,m,s = Target.split(':')
		428	seconds = int(h)3600 + int(m)60 + int(s)
		429	self.seek(seconds, old_state)
		430	return {}
		431
399	def upnp_SetAVTransportURI(self, args, *kwargs):	432	def upnp_SetAVTransportURI(self, args, *kwargs):
400	InstanceID = int(kwargs['InstanceID'])	433	InstanceID = int(kwargs['InstanceID'])
401	CurrentURI = kwargs['CurrentURI']	434	CurrentURI = kwargs['CurrentURI']
Lines 404-415 Link Here
404	#print '>>>', local_protocol_infos	437	#print '>>>', local_protocol_infos
405	if len(CurrentURIMetaData)==0:	438	if len(CurrentURIMetaData)==0:
406	self.load(CurrentURI,CurrentURIMetaData)	439	self.load(CurrentURI,CurrentURIMetaData)
		440	return {}
407	else:	441	else:
408	elt = DIDLLite.DIDLElement.fromString(CurrentURIMetaData)	442	elt = DIDLLite.DIDLElement.fromString(CurrentURIMetaData)
409	#import pdb; pdb.set_trace()	443	#import pdb; pdb.set_trace()
410	if elt.numItems() == 1:	444	if elt.numItems() == 1:
411	item = elt.getItems()[0]	445	item = elt.getItems()[0]
412	res = item.res.get_matching(local_protocol_infos, protocol_type='internal')	446	res = item.res.get_matching(local_protocol_infos, protocol_type='rhythmbox')
413	if len(res) == 0:	447	if len(res) == 0:
414	res = item.res.get_matching(local_protocol_infos)	448	res = item.res.get_matching(local_protocol_infos)
415	if len(res) > 0:	449	if len(res) > 0:

Lines 2-8 Link Here

(-)plugins-old/coherence/upnp_coherence/UpnpSource.py (-49 / +13 lines)
2	# http://opensource.org/licenses/mit-license.php	2	# http://opensource.org/licenses/mit-license.php
3	#	3	#
4	# Copyright 2007, James Livingston <doclivingston@gmail.com>	4	# Copyright 2007, James Livingston <doclivingston@gmail.com>
5	# Copyright 2007, Frank Scholz <coherence@beebits.net>	5	# Copyright 2007,2008 Frank Scholz <coherence@beebits.net>
6		6
7	import rb, rhythmdb	7	import rb, rhythmdb
8	import gobject, gtk	8	import gobject, gtk
Lines 10-15 Link Here
10	from coherence import __version_info__ as coherence_version	10	from coherence import __version_info__ as coherence_version
11		11
12	from coherence import log	12	from coherence import log
		13	from coherence.upnp.core import DIDLLite
13		14
14	class UpnpSource(rb.BrowserSource,log.Loggable):	15	class UpnpSource(rb.BrowserSource,log.Loggable):
15		16
Lines 18-24 Link Here
18	__gproperties__ = {	19	__gproperties__ = {
19	'plugin': (rb.Plugin, 'plugin', 'plugin', gobject.PARAM_WRITABLE\|gobject.PARAM_CONSTRUCT_ONLY),	20	'plugin': (rb.Plugin, 'plugin', 'plugin', gobject.PARAM_WRITABLE\|gobject.PARAM_CONSTRUCT_ONLY),
20	'client': (gobject.TYPE_PYOBJECT, 'client', 'client', gobject.PARAM_WRITABLE\|gobject.PARAM_CONSTRUCT_ONLY),	21	'client': (gobject.TYPE_PYOBJECT, 'client', 'client', gobject.PARAM_WRITABLE\|gobject.PARAM_CONSTRUCT_ONLY),
21	'usn': (gobject.TYPE_PYOBJECT, 'usn', 'usn', gobject.PARAM_WRITABLE\|gobject.PARAM_CONSTRUCT_ONLY),	22	'udn': (gobject.TYPE_PYOBJECT, 'udn', 'udn', gobject.PARAM_WRITABLE\|gobject.PARAM_CONSTRUCT_ONLY),
22	}	23	}
23		24
24	def __init__(self):	25	def __init__(self):
Lines 37-44 Link Here
37	elif property.name == 'client':	38	elif property.name == 'client':
38	self.__client = value	39	self.__client = value
39	self.props.name = self.__client.device.get_friendly_name()	40	self.props.name = self.__client.device.get_friendly_name()
40	elif property.name == 'usn':	41	elif property.name == 'udn':
41	self.__usn = value	42	self.__udn = value
42	else:	43	else:
43	raise AttributeError, 'unknown property %s' % property.name	44	raise AttributeError, 'unknown property %s' % property.name
44		45
Lines 59-73 Link Here
59		60
60		61
61	def load_db(self, id):	62	def load_db(self, id):
62	if coherence_version < (0,5,1):	63	d = self.__client.content_directory.browse(id, browse_flag='BrowseDirectChildren', process_result=False, backward_compatibility=False)
63	d = self.__client.content_directory.browse(id, browse_flag='BrowseDirectChildren', backward_compatibility=False)	64	d.addCallback(self.process_media_server_browse, self.__udn)
64	else:
65	d = self.__client.content_directory.browse(id, browse_flag='BrowseDirectChildren', process_result=False, backward_compatibility=False)
66	d.addCallback(self.process_media_server_browse, self.__usn)
67		65
68		66
69	def state_variable_change(self, variable, usn=None):	67	def state_variable_change(self, variable, udn=None):
70	print "%s changed from %s to %s" % (variable.name, variable.old_value, variable.value)	68	self.info("%s changed from >%s< to >%s<", variable.name, variable.old_value, variable.value)
71	if variable.old_value == '':	69	if variable.old_value == '':
72	return	70	return
73		71
Lines 79-90 Link Here
79	container = changes.pop(0).strip()	77	container = changes.pop(0).strip()
80	update_id = changes.pop(0).strip()	78	update_id = changes.pop(0).strip()
81	if container in self.container_watch:	79	if container in self.container_watch:
82	print "we have a change in %s, container needs a reload" % container	80	self.info("we have a change in %r, container needs a reload", container)
83	self.load_db(container)	81	self.load_db(container)
84		82
85		83
86	def new_process_media_server_browse(self, results, usn):	84	def new_process_media_server_browse(self, results, udn):
87	for item in results:	85	didl = DIDLLite.DIDLElement.fromString(results['Result'])
		86	for item in didl.getItems():
88	self.info("process_media_server_browse %r %r", item.id, item)	87	self.info("process_media_server_browse %r %r", item.id, item)
89	if item.upnp_class.startswith('object.container'):	88	if item.upnp_class.startswith('object.container'):
90	self.load_db(item.id)	89	self.load_db(item.id)
Lines 142-180 Link Here
142		141
143	self.__db.commit()	142	self.__db.commit()
144		143
145
146	def old_process_media_server_browse(self, results, usn):
147	for k,v in results.iteritems():
148	if k == 'items':
149	for id, values in v.iteritems():
150	if values['upnp_class'].startswith('object.container'):
151	self.load_db(id)
152	if values['upnp_class'].startswith('object.item.audioItem'):
153	# (url, [method, something which is in asterix, format, semicolon delimited key=value map of something])
154	resources = [(k, v.split(':')) for (k, v) in values['resources'].iteritems()]
155	# break data into map
156	for r in resources:
157	if r[1][3] is not '*':
158	r[1][3] = dict([v.split('=') for v in r[1][3].split(';')])
159	else:
160	r[1][3] = dict()
161
162	url = None
163	for r in resources:
164	if r[1][3].has_key('DLNA.ORG_CI') and r[1][3]['DLNA.ORG_CI'] is not '1':
165	url = r[0]
166	break
167
168	if url is None:
169	# use transcoded format, since we can't find a normal one
170	url = resources[0][0]
171
172	entry = self.__db.entry_lookup_by_location (url)
173	if entry == None:
174	entry = self.__db.entry_new(self.__entry_type, url)
175
176	self.__db.set(entry, rhythmdb.PROP_TITLE, values['title'])
177
178	self.__db.commit()
179
180	gobject.type_register(UpnpSource)	144	gobject.type_register(UpnpSource)