content_manager.h

Go to the documentation of this file.

/*MT*
    
    MediaTomb - http://www.mediatomb.cc/
    
    content_manager.h - this file is part of MediaTomb.
    
    Copyright (C) 2005 Gena Batyan <bgeradz@mediatomb.cc>,
                       Sergey 'Jin' Bostandzhyan <jin@mediatomb.cc>
    
    Copyright (C) 2006-2010 Gena Batyan <bgeradz@mediatomb.cc>,
                            Sergey 'Jin' Bostandzhyan <jin@mediatomb.cc>,
                            Leonhard Wimmer <leo@mediatomb.cc>
    
    MediaTomb 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.
    
    MediaTomb is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    version 2 along with MediaTomb; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
    
    $Id: content_manager.h 2081 2010-03-23 20:18:00Z lww $
*/

#ifndef __CONTENT_MANAGER_H__
#define __CONTENT_MANAGER_H__

#include "common.h"
#include "cds_objects.h"
#include "storage.h"
#include "dictionary.h"
#include "sync.h"
#include "autoscan.h"
#include "timer.h"
#include "generic_task.h"
#ifdef HAVE_JS
    // this is somewhat not nice, the playlist header needs the cm header and
    // vice versa
    class PlaylistParserScript;
    #include "scripting/playlist_parser_script.h"
#ifdef HAVE_LIBDVDNAV
    class DVDImportScript;
    #include "scripting/dvd_image_import_script.h"
#endif

#endif
#include "layout/layout.h"
#ifdef HAVE_INOTIFY
    #include "autoscan_inotify.h"
#endif

#ifdef EXTERNAL_TRANSCODING
    #include "transcoding/transcoding.h"
#endif

#ifdef ONLINE_SERVICES 
    #include "online_service.h"
#ifdef YOUTUBE
    #include "cached_url.h"
    #include "reentrant_array.h"
    #define  MAX_CACHED_URLS            20
    #define URL_CACHE_CHECK_INTERVAL    300
    //#define URL_CACHE_CHECK_INTERVAL 30
    //#define URL_CACHE_LIFETIME          60
    #define URL_CACHE_LIFETIME          600
#endif
#endif//ONLINE_SERVICES

#if defined (EXTERNAL_TRANSCODING) || defined(SOPCAST)
    #include "executor.h"
#endif

class CMAddFileTask : public GenericTask
{
protected:
    zmm::String path;
    zmm::String rootpath;
    bool recursive;
    bool hidden;
public:
    CMAddFileTask(zmm::String path, zmm::String rootpath, bool recursive=false,
                  bool hidden=false, bool cancellable = true);
    zmm::String getPath();
    zmm::String getRootPath();
    virtual void run();
};

class CMRemoveObjectTask : public GenericTask
{
protected:
    int objectID;
    bool all;
public:
    CMRemoveObjectTask(int objectID, bool all);
    virtual void run();
};

class CMLoadAccountingTask : public GenericTask
{
public:
    CMLoadAccountingTask();
    virtual void run();
};

class CMRescanDirectoryTask : public GenericTask
{
protected: 
    int objectID;
    int scanID;
    scan_mode_t scanMode;
public:
    CMRescanDirectoryTask(int objectID, int scanID, scan_mode_t scanMode,
                          bool cancellable);
    virtual void run();
};

class CMAccounting : public zmm::Object
{
public:
    CMAccounting();
public:
    int totalFiles;
};

#ifdef ONLINE_SERVICES
class CMFetchOnlineContentTask : public GenericTask
{
protected:
    zmm::Ref<OnlineService> service;
    zmm::Ref<Layout> layout;
    bool unscheduled_refresh;

public:
    CMFetchOnlineContentTask(zmm::Ref<OnlineService> service, 
                             zmm::Ref<Layout> layout,
                             bool cancellable, bool unscheduled_refresh);
    virtual void run();
};
#endif

/*
class DirCacheEntry : public zmm::Object
{
public:
    DirCacheEntry();
public:
    int end;
    int id;
};

class DirCache : public zmm::Object
{
protected:
    zmm::Ref<zmm::StringBuffer> buffer;
    int size; // number of entries
    int capacity; // capacity of entries
    zmm::Ref<zmm::Array<DirCacheEntry> > entries;
public:
    DirCache();
    void push(zmm::String name);
    void pop();
    void setPath(zmm::String path);
    void clear();
    zmm::String getPath();
    int createContainers();
};
*/

class ContentManager : public TimerSubscriberSingleton<ContentManager>
{
public:
    class TimerParameter : public zmm::Object
    {
    public:
        enum timer_param_t
        {
            IDAutoscan,
#ifdef ONLINE_SERVICES
            IDOnlineContent,
#ifdef YOUTUBE
            IDURLCache
#endif

#endif
        };

        TimerParameter(timer_param_t param, int id) 
        { 
            this->param = param; 
            this->id = id;
        }

        timer_param_t whoami()  { return param;  }
        void setID(int id)       { this->id = id; }
        int getID()             { return id;     }

    protected:
        timer_param_t param;
        int id;
    };


    ContentManager();
    virtual void init();
    virtual ~ContentManager();
    void shutdown();
    
    virtual void timerNotify(zmm::Ref<zmm::Object> parameter);
    
    bool isBusy() { return working; }
    
    zmm::Ref<CMAccounting> getAccounting();

    zmm::Ref<GenericTask> getCurrentTask();

    zmm::Ref<zmm::Array<GenericTask> > getTasklist();

    void invalidateTask(unsigned int taskID, task_owner_t taskOwner = ContentManagerTask);

    
    /* the functions below return true if the task has been enqueued */
    
    /* sync/async methods */
    void loadAccounting(bool async=true);

    int addFile(zmm::String path, bool recursive=true, bool async=true, 
                bool hidden=false, bool lowPriority=false, 
                bool cancellable=true);

    int ensurePathExistence(zmm::String path);
    void removeObject(int objectID, bool async=true, bool all=false);
    void rescanDirectory(int objectID, int scanID, scan_mode_t scanMode,
                         zmm::String descPath = nil, bool cancellable = true);

    void updateObject(int objectID, zmm::Ref<Dictionary> parameters);

    zmm::Ref<CdsObject> createObjectFromFile(zmm::String path, 
                                             bool magic=true, 
                                             bool allow_fifo=false);

#ifdef ONLINE_SERVICES
    void fetchOnlineContent(service_type_t service, bool lowPriority=true, 
                            bool cancellable=true, 
                            bool unscheduled_refresh = false);

    void cleanupOnlineServiceObjects(zmm::Ref<OnlineService> service);

#ifdef YOUTUBE
    void cacheURL(zmm::Ref<CachedURL> url);
    zmm::String getCachedURL(int objectID);
#endif
#endif//ONLINE_SERVICES

    void addVirtualItem(zmm::Ref<CdsObject> obj, bool allow_fifo=false);

    void addObject(zmm::Ref<CdsObject> obj);

    int addContainerChain(zmm::String chain, zmm::String lastClass = nil,
            int lastRefID = INVALID_OBJECT_ID);
    
    void addContainer(int parentID, zmm::String title, zmm::String upnpClass);
    
    void updateObject(zmm::Ref<CdsObject> obj, bool send_updates = true);

    zmm::Ref<CdsObject> convertObject(zmm::Ref<CdsObject> obj, int objectType);

    zmm::Ref<AutoscanDirectory> getAutoscanDirectory(int scanID, scan_mode_t scanMode);

    zmm::Ref<AutoscanDirectory> getAutoscanDirectory(zmm::String location);
    void removeAutoscanDirectory(int scanID, scan_mode_t scanMode);

    void removeAutoscanDirectory(zmm::String location);
    
    void removeAutoscanDirectory(int objectID);
 
    void setAutoscanDirectory(zmm::Ref<AutoscanDirectory> dir);

    void handlePeristentAutoscanRemove(int scanID, scan_mode_t scanMode);

    void handlePersistentAutoscanRecreate(int scanID, scan_mode_t scanMode);

    zmm::Ref<zmm::Array<AutoscanDirectory> > getAutoscanDirectories(scan_mode_t scanMode);

    zmm::Ref<zmm::Array<AutoscanDirectory> > getAutoscanDirectories();


    void reloadLayout();

#if defined(EXTERNAL_TRANSCODING) || defined(SOPCAST)
    void registerExecutor(zmm::Ref<Executor> exec);

    void unregisterExecutor(zmm::Ref<Executor> exec);
#endif

#ifdef HAVE_MAGIC
    zmm::String getMimeTypeFromBuffer(void *buffer, size_t length);
#endif
protected:
    void initLayout();
    void destroyLayout();

#ifdef HAVE_JS
    void initJS();
    void destroyJS();
#endif
    
    zmm::Ref<RExp> reMimetype;

    bool ignore_unknown_extensions;
    bool extension_map_case_sensitive;

    zmm::Ref<Dictionary> extension_mimetype_map;
    zmm::Ref<Dictionary> mimetype_upnpclass_map;
    zmm::Ref<Dictionary> mimetype_contenttype_map;

    zmm::Ref<AutoscanList> autoscan_timed;
#ifdef HAVE_INOTIFY
    zmm::Ref<AutoscanList> autoscan_inotify;
    zmm::Ref<AutoscanInotify> inotify;
#endif
 
#if defined(EXTERNAL_TRANSCODING) || defined(SOPCAST)
    zmm::Ref<Mutex> pr_mutex;
    zmm::Ref<zmm::Array<Executor> > process_list;
#endif

    void _loadAccounting();

    int addFileInternal(zmm::String path, zmm::String rootpath, 
                        bool recursive=true,
                        bool async=true, bool hidden=false,
                        bool lowPriority=false, 
                        unsigned int parentTaskID = 0,
                        bool cancellable = true);
    int _addFile(zmm::String path, zmm::String rootpath, bool recursive=false, bool hidden=false, zmm::Ref<GenericTask> task=nil);
    //void _addFile2(zmm::String path, bool recursive=0);
    void _removeObject(int objectID, bool all);
    
    void _rescanDirectory(int containerID, int scanID, scan_mode_t scanMode, scan_level_t scanLevel, zmm::Ref<GenericTask> task=nil);
    /* for recursive addition */
    void addRecursive(zmm::String path, bool hidden, zmm::Ref<GenericTask> task);
    //void addRecursive2(zmm::Ref<DirCache> dirCache, zmm::String filename, bool recursive);
    
    zmm::String extension2mimetype(zmm::String extension);
    zmm::String mimetype2upnpclass(zmm::String mimeType);

    void invalidateAddTask(zmm::Ref<GenericTask> t, zmm::String path);
    
    zmm::Ref<Layout> layout;

#ifdef ONLINE_SERVICES 
    zmm::Ref<OnlineServiceList> online_services;

    void fetchOnlineContentInternal(zmm::Ref<OnlineService> service,
                                    bool lowPriority=true,
                                    bool cancellable=true,
                                    unsigned int parentTaskID = 0,
                                    bool unscheduled_refresh = false);

    void _fetchOnlineContent(zmm::Ref<OnlineService>, 
                             unsigned int parentTaskID, 
                             bool unscheduled_refresh);

#ifdef YOUTUBE
    zmm::Ref<Mutex> urlcache_mutex;
    zmm::Ref<ReentrantArray<CachedURL> > cached_urls;
    void checkCachedURLs();
#endif

#endif //ONLINE_SERVICES 

#ifdef HAVE_JS
    zmm::Ref<PlaylistParserScript> playlist_parser_script;
#ifdef HAVE_LIBDVDNAV
    zmm::Ref<DVDImportScript> dvd_import_script;
#endif
#endif

    bool layout_enabled;
    
    void setLastModifiedTime(time_t lm);
    
    inline void signal() { cond->signal(); }
    static void *staticThreadProc(void *arg);
    void threadProc();
    
    void addTask(zmm::Ref<GenericTask> task, bool lowPriority = false);
    
    zmm::Ref<CMAccounting> acct;
    
    pthread_t taskThread;
    zmm::Ref<Cond> cond;
    
    bool working;
    
    bool shutdownFlag;
    
    zmm::Ref<zmm::ObjectQueue<GenericTask> > taskQueue1; // priority 1
    zmm::Ref<zmm::ObjectQueue<GenericTask> > taskQueue2; // priority 2
    zmm::Ref<GenericTask> currentTask;

    unsigned int taskID;

    friend void CMAddFileTask::run();
    friend void CMRemoveObjectTask::run();
    friend void CMRescanDirectoryTask::run();
#ifdef ONLINE_SERVICES
    friend void CMFetchOnlineContentTask::run();
#endif
    friend void CMLoadAccountingTask::run();
};

#endif // __CONTENT_MANAGER_H__

---