connection.h

Go to the documentation of this file.

 
#pragma once
 
#include <config.h>
 
#include <football/football.h>
#include <parsnip/parsnip_command.h>
 
#include "fundamentals.h"
#include "response.h"
#include "interpreter.h"
#include "user.h"
 
class PianodService;
namespace Media {
    class Source;
}
//class ThingieList;
 
class WaitEvent {
public:
    enum class Type {
        None,
        SourceReady,
        TrackEnded,
        TrackStarted
    };
    Type event = Type::None; 
    const void *parameter; 
    time_t timeout = 0; 
    bool close_after_event = false; 
 
    static time_t nextTimeout;
};
 
namespace WaitOptions {
    extern const Parsnip::OptionParser::Definitions &parser_definitions ();
    extern void extract_options (const Parsnip::Data &options, WaitEvent &dest);
};
 
 
class PianodConnection : public Football::Connection {
    // Override original event handlers 
    virtual void newConnection (const FB_EVENT *event) override;
    virtual void connectionClose (const FB_EVENT *event) override;
    virtual void inputReceived (const FB_EVENT *event) override;
 
    // Connection state
    Media::Source * _source = nullptr; 
    WaitEvent pending; 
    bool use_json = false; 
 
public:
    virtual ~PianodConnection () override;
    inline bool transmitJSON () const {
        return use_json;
    }
 
    static bool json_connections_only (FB_CONNECTION *);
    static bool line_connections_only (FB_CONNECTION *);
    
    // Now add pianod junk
    // Visibility of this item should be adjusted later??? ZZZZZ 
    User *user = nullptr;
 
    void close_after_events ();
    inline bool authenticated (void) const { return user != nullptr; };
    ResponseGroup updateConnection ();
    inline std::string username (void) const { return authenticated() ? user->username() : "A visitor"; };
    inline Media::Source * const source() const { return _source; };
    [[nodiscard]] ResponseGroup source (Media::Source * const source, bool announce = true);
    bool haveRank (Rank rank) const;
    Rank effectiveRank (void) const;
    bool havePrivilege (Privilege priv) const;
 
    void waitForEventWithOptions (WaitEvent::Type type, const Parsnip::Data &options, const void *detail);
    void waitForEvent (WaitEvent::Type type, const void *detail);
    void event (WaitEvent::Type type, const void *detail, RESPONSE_CODE reply);
    void checkTimeouts ();
 
    [[nodiscard]] ResponseGroup sendSelectedSource () const;
    [[nodiscard]] ResponseGroup sendEffectivePrivileges () const;
    void announceToRoom (ResponseGroup &&announcement) const;
    void announceToAll (ResponseGroup &&announcement) const;
 
    inline PianodService &service (void) const {
        return *((PianodService *) Football::Connection::service());
    }
};
 
 
class AudioEngine;
class ServiceManager;
 
class PianodService : public Football::Service<PianodConnection> {
    friend class ServiceManager;
private:
    AudioEngine *engine = nullptr;
    const std::string room_name;
public:
    PianodDispatcher dispatch;
 
    ~PianodService ();
    PianodService (const FB_SERVICE_OPTIONS &options,
                   const std::string &room,
                   const AudioSettings &audio,
                   PianodService *parent,
                   const Parsnip::ParserRef &parser,
                   const PianodSchemaRef &schema);
    inline AudioEngine *audioEngine() { return engine; };
    void serviceShutdown (void);
    inline const std::string &roomName (void) { return room_name; };
    void usersChangedNotification (void);
    void announceToRoom (const Response &message);
    void announceToRoom (const ResponseGroup &message);
};