mediaunit.h

Go to the documentation of this file.

 
#pragma once
 
#include <config.h>
 
#include <cstdio>
 
#include <string>
#include <unordered_map>
#include <functional>
#include <memory>
 
#include "fundamentals.h"
#include "musictypes.h"
#include "filter.h"
#include "ownership.h"
 
namespace Parsnip {
    class Data;
}
 
namespace Media {
    class SourceParameters;
    class Player;
    class Manager;
    class SplitId;
 
    namespace Key {
        extern const char *Source;
        extern const char *SourceId;
        extern const char *SourceKind;
        extern const char *SourceName;
    }
 
    struct Statistics {
        int songs_attempted = 0;
        int tracks_played = 0;
        int playback_failures = 0;
        int sequential_failures = 0;
        int songs_replaced = 0;
        int songs_donated = 0;
    };
 
    enum class SelectionMethod {
        Song,       
        Album,      
        Artist,     
        Playlist,   
        Random      
    };
 
    class Source : public PrimaryOwnership {
        friend class Manager;
    public:
        typedef unsigned long SerialNumber;
 
    protected:
        enum class State {
            INITIALIZING,   
            VALID,          
            READY,          
            DEAD            
        };
        State state = State::INITIALIZING;
 
        const SourceParameters *parameters = nullptr;
 
    private:
        // Some state manipulated by the media manager
        SerialNumber serialNum = 0; 
        State announced_state = State::INITIALIZING; 
        Statistics statistics; 
        time_t lockout_until = 0;
 
        static void defaultStatusHandler (RESPONSE_CODE status, const char *detail);
        std::function <void (RESPONSE_CODE status, const char *detail)> statusHandler = defaultStatusHandler;
        
    public:
        Source (SourceParameters *params);
        virtual ~Source (void);
        
        void persist (void) const;
        virtual bool flush (void);
        inline bool isReady (void) const { return state == State::READY; };
        inline SerialNumber serialNumber (void) const { return (serialNum); };
        inline const Statistics &getStatistics () const { return statistics; };
        inline const bool isLockedOut () const { return lockout_until > time(nullptr); };
 
        Parsnip::Data serializeIdentity() const;
        std::string identify() const;
        void alert (RESPONSE_CODE message) const;
        void alert (RESPONSE_CODE message, const char *detail, const char *reason = nullptr) const;
        void reportStatus (const char *detail) const;
        inline void reportStatus (const std::string &detail) const {
            reportStatus (detail.c_str());
        };
 
        // Identity
        virtual const char *kind (void) const = 0;
        const std::string &name (void) const;
        std::string key (void) const {
            return std::string (kind()) + "#" + name();
        }
        std::string filename (void) const {
            return std::string (kind()) + "-" + name() + ".json";
        }
 
        // Capabilities
        virtual bool canExpandToAllSongs (void) const;
        virtual bool requireNameForCreatePlaylist (void) const;
 
        // Playlist methods
        PianodPlaylist *getPlaylistByName (const char *name);
 
        virtual PlaylistList getPlaylists (const Filter &filter = Filter::All) = 0;
        virtual PianodPlaylist *getMixPlaylist (void) = 0;
        virtual PianodPlaylist *getEverythingPlaylist (void) = 0;
        virtual PianodPlaylist *getTransientPlaylist (const Filter &criteria);
        virtual PianodPlaylist *createPlaylist (const char *name,
                                              MusicThingie::Type type,
                                              MusicThingie *from);
        virtual PianodPlaylist *createPlaylist (const char *name, const Filter &filter);
        virtual MusicThingie *getAnythingById (const SplitId &id) = 0;
 
        // Miscellaneous 
        virtual Player *getPlayer (const AudioSettings &audio, PianodSong *song) = 0;
        virtual SongList getRandomSongs (PianodPlaylist *playlist, const UserList &users,
                                         SelectionMethod selectionMethod) = 0;
        virtual ThingieList getSuggestions (const Filter &filter, SearchRange what = SearchRange::EXHAUSTIVE) = 0;
        virtual float periodic (void);
        void playbackComplete (bool played, bool successfully);
        virtual void playbackProblem (void) { };
 
        // Sourcecasts
        virtual MusicThingie *getSuggestion (MusicThingie *thing,
                                             MusicThingie::Type type,
                                             SearchRange where = SearchRange::SHALLOW) = 0;
 
        inline MusicThingie *getSuggestion (MusicThingie *thing,
                                            SearchRange where = SearchRange::SHALLOW) {
            return getSuggestion (thing, thing->type(), where);
        }
    protected:
        MusicThingie *getSuggestion (MusicThingie *thing,
                                     MusicThingie::Type type,
                                     SearchRange where,
                                     bool fully_confirm);
    };
    using SourcePtr = std::unique_ptr<Source>;
 
    class SplitId {
    public:
        const std::string wholeId; 
        Source::SerialNumber serialNumber; 
        Source *source; 
        MusicThingie::Type type; 
        std::string innerId; 
 
        explicit SplitId (const std::string &id);
    };
    
}