Ticket #240: daap_storage.py

# -*- coding: utf-8 -*-

# Licensed under the MIT license
# http://opensource.org/licenses/mit-license.php

# Copyright 2009, Florian Wiesweg <Flo@Wiesweg-net.de>

# DEPENDS ON:
#   - PythonDaap (http://jerakeen.org/code/pythondaap/) by Tom Insam
#        (tom@jerakeen.org)
#
# TODO:
#   - add support for more mimetypes (e.g. flac, videos, images?)
#       concerning images: I heard of Apple's iPhoto using a similar protocol to
#       share images, is this also possible with python-daap? it's a pity I
#       don't have a Mac to test it
#   - cleanup: DaapSession.logout() when coherence shuts down
#   - seperate containers: genres, artists, albums like in ampache_storage?
#       would require additional sorting since they are only passed as
#       attributes of the music tracks and not in seperate lists, so it would be
#       quite a piece of work
#
# UNTESTED:
#   - playlists - seem to work (tested with gupnp-universal-cp), but I've got no
#      application capable of really using them (neither GNOME Totem, Rhythmbox)
#
# CONFIGURATION:
# - remoteServer: name or address of the DAAP-Server hosting the share
#     default: 'localhost'
# - remotePort: listening port of the DAAP-Server
#     default: 3689 (default port of DAAP, AFAIK)
# - databaseName: name of the  database to read the music from
#     note: normally a DAAP share hosts only a single database,
#       so this can normally be left out, daap_storage chooses
#       it automatically
#     default: None
# - password: password securing the share, only needed if one is set
#     default: None
# - refresh: time between regular updates of the UPnP data (in minutes)
#     default: 5
#           

from coherence.backend import BackendStore
from coherence.backend import BackendItem
from coherence.upnp.core import DIDLLite
import coherence.extern.louie as louie
from twisted.internet import reactor

from daap import DAAPClient

class DaapMusicTrack(BackendItem):

    # translate dmap.itemkind to MIME type for UPnP
    typeMap = {'mp3':'audio/mpeg3',
            'ogg':'audio/ogg' # unsure if this is right for ogg on the DAAP side
    }

    def __init__(self, parent_id, track, location):
        self.daapTrack = track
        self.update_id = 0
        self.id = self.daapTrack.id
        self.parent_id = parent_id
        self.name = self.daapTrack.name
        self.location = location

        self.item = DIDLLite.MusicTrack(id, parent_id, self.name)
        self.item.album = self.daapTrack.album
        self.item.contributor = self.daapTrack.artist
        try:
            self.item.genre = self.daapTrack.asgn
        except (AttributeError):
            pass

        type = 'http-get:*:' + self.getMimeType(self.daapTrack) + ':*'
        res = DIDLLite.Resource(self.location, type)
        res.size = self.daapTrack.size
        self.item.res.append(res)

    def getMimeType(self, daapTrack):
        if DaapMusicTrack.typeMap.has_key(daapTrack.type):
            return DaapMusicTrack.typeMap[daapTrack.type]
        else:
            return 'application/octet-stream'

    def get_id(self):
        return self.id

    def get_name(self):
        return self.name

class DaapContainer(BackendItem):
    def __init__(self, id, parent_id, name):
        BackendItem.__init__(self)
        self.parent_id = parent_id
        self.id = id
        self.name = name
        self.mimetype = 'directory'
        self.update_id = 0
        self.item = DIDLLite.Container(id, parent_id, self.name)
        self.children = []
        
    def get_children(self, start=0, end=0):
        if end != 0:
            return self.children[start:end]
        return self.children[start:]
        
    def get_child_count(self):
        return len(self.children)
    
    def get_id(self):
        return self.id

    def get_item(self):
        return self.item
    
class DaapPlaylist(DaapContainer):
    def __init__(self, id, parent_id, name, musicTracks):
        self.id = id
        self.parent_id = parent_id
        self.name = name
        self.children = musicTracks
        self.item = DIDLLite.PlaylistItem(self.id, parent_id, self.name)
        self.item.childCount = len(musicTracks)
    
    def get_name(self):
        return self.name

class DaapStore(BackendStore):
    
    implements = ["MediaServer"]
    logCategory = 'daap_store'

    ROOT_CONTAINER_ID = 0
    next_id = 1000
    
    def __init__(self, server, **kwargs):
        BackendStore.__init__(self, server, **kwargs)
        
        self.name = kwargs.get('name', 'Daap' )
        self.remoteServer = kwargs.get('remoteServer', 'localhost')
        self.remotePort =  int(kwargs.get('remotePort', 3689))
        self.databaseName = kwargs.get('database', None)
        self.password = kwargs.get('password', None)
        self.refresh = int(kwargs.get('refresh', 5))

        self.daapItems = {}
        self.container= DaapContainer(self.ROOT_CONTAINER_ID, None, 'root' )
        self.wmc_mapping = {'16': 0}

        self.update_loop()

    def upnp_init(self):
        self.server.connection_manager_server.set_variable(
                            0, 'SourceProtocolInfo',
                            ['http-get:*:audio/mpeg:*',
                             'http-get:*:application/ogg:*',])

    def _update_container(self, result=None):
        if self.server:
            self.server.content_directory_server.set_variable(0,
                    'SystemUpdateID', self.update_id)
            value = (self.ROOT_CONTAINER_ID,self.container.update_id)
            self.server.content_directory_server.set_variable(0,
                    'ContainerUpdateIDs', value)
        return result

    def update_loop(self):
        self.connect()
        self.update_data()
        reactor.callLater(self.refresh * 60, self.update_loop)

    def connect(self):
        self.client = DAAPClient()
        self.client.connect(self.remoteServer, self.remotePort, self.password)
        self.session = self.client.login()

        if self.session is None:
            self.error('could not connect to daap server %s, port %d',
                        self.server, self.port)
            return

        databases = self.session.databases()
        if self.databaseName is None:
            self.databaseName = self.session.library().name

        self.database=None
        for d in databases:
            if d.name == self.databaseName:
                self.database = d

    def update_data(self):
        remoteMusicTracks = self.database.tracks()
        self.daapItems = {}
        self.container= DaapContainer(None, self.ROOT_CONTAINER_ID, 'root' )

        for t in remoteMusicTracks:
            location = self.get_url_by_daap_track(t)
            musicTrack = DaapMusicTrack(
                                self.ROOT_CONTAINER_ID, t, location)
            self.container.children.append(musicTrack)
            self.daapItems[t.id] = musicTrack
            
        remotePlaylists = self.database.playlists()

        for p in remotePlaylists:
            if p.id == 1:
                continue
            playlistTracks = []
            remotePlaylistTracks = p.tracks()
            for t in remotePlaylistTracks:
                    playlistTracks.append(self.get_by_id(t.id))

            playlist = DaapPlaylist(p.id, self.ROOT_CONTAINER_ID,
                                    p.name, playlistTracks)
            self.container.children.append(playlist)
            self.daapItems[p.id] = playlist

        self.container.update_id += 1
        self.update_id += 1
        louie.send('Coherence.UPnP.Backend.init_completed', None, backend=self)
        
    def get_by_id(self, id):
        if isinstance(id, basestring):
            id = id.split('@',1)
            id = id[0]
        if int(id) == self.ROOT_CONTAINER_ID:
            return self.container
        return self.daapItems.get(int(id), None)

    def get_url_by_daap_track(self, daapTrack):
        self.connect()
        return 'http://' + str(self.remoteServer) + ':' + str(self.remotePort) \
            + '/databases/' + str(self.database.id)  \
            + '/items/' + str(daapTrack.id) \
            + '.mp3?session-id=' + str(self.session.sessionid)

if __name__ == '__main__':

    from coherence.base import Coherence
    from twisted.internet import reactor

    def main():
        def got_result(result):
            print "got_result"


        config = {}
        config['logmode'] = 'debug'
        c = Coherence(config)
        f = c.add_plugin('DaapStore',
            remoteServer='homeServer.local',
            name="DAAP Test Store"
            )

    #store = DaapStore(None, remoteServer='homeServer.local',
    #                  name='DAAP Test Store 2')
    reactor.callWhenRunning(main)
    reactor.run()